





'''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     __lowerCAmelCase					(   _SCREAMING_SNAKE_CASE						,						_SCREAMING_SNAKE_CASE						,						_SCREAMING_SNAKE_CASE						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Optional[int]						    =   StableDiffusionAttendAndExcitePipeline
       _snake_case     :					str						    =   False
       _snake_case     :					Any						    =   TEXT_TO_IMAGE_PARAMS
       _snake_case     :					List[str]						    =   TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}			)
       _snake_case     :					List[str]						    =   TEXT_TO_IMAGE_IMAGE_PARAMS
       _snake_case     :					Tuple						    =   TEXT_TO_IMAGE_IMAGE_PARAMS





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

            '''simple docstring'''




            super().setUpClass()
            torch.use_deterministic_algorithms(lowerCAmelCase__					)





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

            '''simple docstring'''




            super().tearDownClass()
            torch.use_deterministic_algorithms(lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					List[Any]:

            '''simple docstring'''




            torch.manual_seed(0					)
            _UpperCamelCase       =	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=lowerCAmelCase__	,			)
            _UpperCamelCase       =	DDIMScheduler(
                beta_start=0.00085	,			beta_end=0.012	,			beta_schedule='''scaled_linear'''	,			clip_sample=lowerCAmelCase__	,			set_alpha_to_one=lowerCAmelCase__	,			)
            torch.manual_seed(0					)
            _UpperCamelCase       =	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					)
            _UpperCamelCase       =	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=1000	,			hidden_act='''gelu'''	,			projection_dim=512	,			)
            _UpperCamelCase       =	CLIPTextModel(lowerCAmelCase__					)
            _UpperCamelCase       =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

            _UpperCamelCase       =	{
                """unet""": unet,
                """scheduler""": scheduler,
                """vae""": vae,
                """text_encoder""": text_encoder,
                """tokenizer""": tokenizer,
                """safety_checker""": None,
                """feature_extractor""": None,
            }

            return components





       def snake_case__						(							self       :		Tuple	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		List[Any]=0					)   ->					Tuple:

            '''simple docstring'''




            if str(lowerCAmelCase__					).startswith('''mps'''					):
                 _UpperCamelCase       =	torch.manual_seed(lowerCAmelCase__					)
            else:
                 _UpperCamelCase       =	torch.Generator(device=lowerCAmelCase__					).manual_seed(lowerCAmelCase__					)
            _UpperCamelCase       =	{
                """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 snake_case__						(							self       :		Tuple					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	"""cpu"""

            _UpperCamelCase       =	self.get_dummy_components()
            _UpperCamelCase       =	self.pipeline_class(**lowerCAmelCase__					)
            pipe.to(lowerCAmelCase__					)
            pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

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

            self.assertEqual(image.shape	,			(1, 64, 64, 3)					)
            _UpperCamelCase       =	np.array(
                [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]					)
            _UpperCamelCase       =	np.abs(image_slice.flatten() - expected_slice					).max()
            self.assertLessEqual(lowerCAmelCase__	,			1e-3					)





       def snake_case__						(							self       :		List[str]					)   ->					List[Any]:

            '''simple docstring'''




            super().test_cpu_offload_forward_pass(expected_max_diff=5e-4					)





       def snake_case__						(							self       :		Any					)   ->					Any:

            '''simple docstring'''




            self._test_inference_batch_consistent(batch_sizes=[1, 2]					)





       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            self._test_inference_batch_single_identical(batch_size=2	,			expected_max_diff=7e-4					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[int]:

            '''simple docstring'''




            super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)





       def snake_case__						(							self       :		Dict					)   ->					str:

            '''simple docstring'''




            super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4					)





       def snake_case__						(							self       :		List[Any]					)   ->					int:

            '''simple docstring'''




            super().test_save_load_local(expected_max_difference=5e-4					)







       def snake_case__						(							self       :		Optional[Any]					)   ->					Any:

            '''simple docstring'''




            super().test_save_load_optional_components(expected_max_difference=4e-4					)

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






       """simple docstring"""





       @classmethod
       def snake_case__						(							cls       :		Tuple					)   ->					List[str]:

            '''simple docstring'''




            super().setUpClass()
            torch.use_deterministic_algorithms(lowerCAmelCase__					)





       @classmethod
       def snake_case__						(							cls       :		Tuple					)   ->					Tuple:

            '''simple docstring'''




            super().tearDownClass()
            torch.use_deterministic_algorithms(lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					List[Any]:

            '''simple docstring'''




            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()







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

            '''simple docstring'''




            _UpperCamelCase       =	torch.manual_seed(51					)

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

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

            _UpperCamelCase       =	pipe(
                prompt=lowerCAmelCase__	,			token_indices=lowerCAmelCase__	,			guidance_scale=7.5	,			generator=lowerCAmelCase__	,			num_inference_steps=5	,			max_iter_to_alter=5	,			output_type='''numpy'''	,			).images[0]

            _UpperCamelCase       =	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 typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__						:      Optional[Any]	=    {
    'configuration_autoformer': [
        'AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AutoformerConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowercase__						:      List[Any]	=    [
       'AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'AutoformerForPrediction',
       'AutoformerModel',
       'AutoformerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_autoformer import (
       AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       AutoformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_autoformer import (
          AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          AutoformerForPrediction,
          AutoformerModel,
          AutoformerPreTrainedModel,
      )

else:
   import sys

   lowercase__						:      Tuple	=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



