





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 :   int  			=  False


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







       @classmethod
       def 						__lowerCamelCase   (				cls					:     Optional[int]      )       ->List[Any]:
          super().setUpClass()
          torch.use_deterministic_algorithms(_snake_case      )







       @classmethod
       def 						__lowerCamelCase   (				cls					:     Optional[Any]      )       ->Any:
          super().tearDownClass()
          torch.use_deterministic_algorithms(_snake_case      )







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->Tuple:
          torch.manual_seed(0      )
          lowerCamelCase__       :						Tuple        =							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=_snake_case		, )
          lowerCamelCase__       :						Dict        =							DDIMScheduler(
              beta_start=0.0_00_85		, beta_end=0.0_12		, beta_schedule='''scaled_linear'''		, clip_sample=_snake_case		, set_alpha_to_one=_snake_case		, )
          torch.manual_seed(0      )
          lowerCamelCase__       :						Dict        =							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[str]        =							CLIPTextModel(_snake_case      )
          lowerCamelCase__       :						Union[str, Any]        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

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

          return components







       def 						__lowerCamelCase   (				self					:     Dict		, A					:     Optional[int]		, A					:     List[Any]=0      )       ->List[str]:


          if str(_snake_case      ).startswith('''mps'''      ):
             lowerCamelCase__       :						Any        =							torch.manual_seed(_snake_case      )
          else:
             lowerCamelCase__       :						Tuple        =							torch.Generator(device=_snake_case      ).manual_seed(_snake_case      )
          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 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Union[str, Any]:
          lowerCamelCase__       :						Dict        =							'''cpu'''

          lowerCamelCase__       :						Dict        =							self.get_dummy_components()
          lowerCamelCase__       :						Any        =							self.pipeline_class(**_snake_case      )
          pipe.to(_snake_case      )
          pipe.set_progress_bar_config(disable=_snake_case      )

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

          self.assertEqual(image.shape		, (1, 6_4, 6_4, 3)      )
          lowerCamelCase__       :						Optional[Any]        =							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__       :						str        =							np.abs(image_slice.flatten() - expected_slice      ).max()
          self.assertLessEqual(_snake_case		, 1e-3      )







       def 						__lowerCamelCase   (				self					:     str      )       ->List[Any]:
          super().test_cpu_offload_forward_pass(expected_max_diff=5e-4      )







       def 						__lowerCamelCase   (				self					:     Dict      )       ->Optional[int]:
          self._test_inference_batch_consistent(batch_sizes=[1, 2]      )







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->str:
          self._test_inference_batch_single_identical(batch_size=2		, expected_max_diff=7e-4      )







       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->Dict:
          super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3      )







       def 						__lowerCamelCase   (				self					:     int      )       ->Union[str, Any]:
          super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4      )







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







       def 						__lowerCamelCase   (				self					:     Tuple      )       ->Tuple:
          super().test_save_load_optional_components(expected_max_difference=4e-4      )


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







       @classmethod
       def 						__lowerCamelCase   (				cls					:     Any      )       ->Optional[Any]:
          super().setUpClass()
          torch.use_deterministic_algorithms(_snake_case      )







       @classmethod
       def 						__lowerCamelCase   (				cls					:     Tuple      )       ->Tuple:
          super().tearDownClass()
          torch.use_deterministic_algorithms(_snake_case      )







       def 						__lowerCamelCase   (				self					:     str      )       ->Optional[Any]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->List[str]:
          lowerCamelCase__       :						Union[str, Any]        =							torch.manual_seed(5_1      )

          lowerCamelCase__       :						Any        =							StableDiffusionAttendAndExcitePipeline.from_pretrained(
              '''CompVis/stable-diffusion-v1-4'''		, safety_checker=_snake_case		, torch_dtype=torch.floataa      )
          pipe.to('''cuda'''      )

          lowerCamelCase__       :						int        =							'''a painting of an elephant with glasses'''
          lowerCamelCase__       :						Dict        =							[5, 7]

          lowerCamelCase__       :						Optional[Any]        =							pipe(
              prompt=_snake_case		, token_indices=_snake_case		, guidance_scale=7.5		, generator=_snake_case		, num_inference_steps=5		, max_iter_to_alter=5		, output_type='''numpy'''		, ).images[0]

          lowerCamelCase__       :						Optional[Any]        =							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
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_A :   Tuple  			=  logging.get_logger(__name__)

_A :   List[str]  			=  {
    'shi-labs/nat-mini-in1k-224': 'https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json',
    # See all Nat models at https://huggingface.co/models?filter=nat
}


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_					,lowerCAmelCase_ ):
       _UpperCAmelCase				:  Dict			   =   "nat"

       _UpperCAmelCase				:  Tuple			   =   {
           "num_attention_heads": "num_heads",
           "num_hidden_layers": "num_layers",
       }







       def __init__(				self					:     List[Any]		, A					:     Union[str, Any]=4		, A					:     str=3		, A					:     List[Any]=6_4		, A					:     Optional[Any]=[3, 4, 6, 5]		, A					:     int=[2, 4, 8, 1_6]		, A					:     Optional[int]=7		, A					:     List[Any]=3.0		, A					:     str=True		, A					:     str=0.0		, A					:     Any=0.0		, A					:     int=0.1		, A					:     Tuple="gelu"		, A					:     List[Any]=0.02		, A					:     str=1e-5		, A					:     Optional[int]=0.0		, A					:     Optional[Any]=None		, A					:     Dict=None		, **A					:     str		, )       ->Union[str, Any]:
          super().__init__(**A      )

          lowerCamelCase__       :						Any        =							patch_size
          lowerCamelCase__       :						Optional[Any]        =							num_channels
          lowerCamelCase__       :						Any        =							embed_dim
          lowerCamelCase__       :						str        =							depths
          lowerCamelCase__       :						Union[str, Any]        =							len(A      )
          lowerCamelCase__       :						int        =							num_heads
          lowerCamelCase__       :						Optional[int]        =							kernel_size
          lowerCamelCase__       :						Optional[int]        =							mlp_ratio
          lowerCamelCase__       :						List[Any]        =							qkv_bias
          lowerCamelCase__       :						Tuple        =							hidden_dropout_prob
          lowerCamelCase__       :						List[str]        =							attention_probs_dropout_prob
          lowerCamelCase__       :						List[Any]        =							drop_path_rate
          lowerCamelCase__       :						Union[str, Any]        =							hidden_act
          lowerCamelCase__       :						Union[str, Any]        =							layer_norm_eps
          lowerCamelCase__       :						List[Any]        =							initializer_range
          # we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
          # this indicates the channel dimension after the last stage of the model
          lowerCamelCase__       :						str        =							int(embed_dim * 2 ** (len(A      ) - 1)      )
          lowerCamelCase__       :						Dict        =							layer_scale_init_value
          lowerCamelCase__       :						Dict        =							['''stem'''] + [F"stage{idx}" for idx in range(1		, len(A      ) + 1      )]
          lowerCamelCase__       ,							lowerCamelCase__       :						str        =							get_aligned_output_features_output_indices(
              out_features=A		, out_indices=A		, stage_names=self.stage_names      )



