





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





@skip_mps
class 					A__       (				A_					,    A_					,    A_					,    unittest.TestCase      ):




   """simple docstring"""



   __A  :							Any			    =    StableDiffusionAttendAndExcitePipeline
   __A  :							Dict			    =    False
   __A  :							int			    =    TEXT_TO_IMAGE_PARAMS
   __A  :							Union[str, Any]			    =    TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}      )
   __A  :							str			    =    TEXT_TO_IMAGE_IMAGE_PARAMS
   __A  :							str			    =    TEXT_TO_IMAGE_IMAGE_PARAMS

   @classmethod
   def 				__lowercase						(   cls)     ->		List[Any]:







          '''simple docstring'''

          super().setUpClass()
          torch.use_deterministic_algorithms(lowercase)

   @classmethod
   def 				__lowercase						(   cls)     ->		Optional[Any]:







          '''simple docstring'''

          super().tearDownClass()
          torch.use_deterministic_algorithms(lowercase)

   def 				__lowercase						(   self)     ->		Dict:







          '''simple docstring'''

          torch.manual_seed(0)
          a__		:      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=lowercase   ,    )
          a__		:      int					=							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__		:      str					=							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__		:      Dict					=							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__		:      Dict					=							CLIPTextModel(lowercase)
          a__		:      int					=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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

          return components

   def 				__lowercase						(   self   ,    lowercase   ,    lowercase=0)     ->		Any:







          '''simple docstring'''

          if str(lowercase).startswith('mps'):
                 a__		:      Tuple					=							torch.manual_seed(lowercase)
          else:
                 a__		:      Any					=							torch.Generator(device=lowercase).manual_seed(lowercase)
          a__		:      Union[str, 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 				__lowercase						(   self)     ->		List[Any]:







          '''simple docstring'''

          a__		:      Dict					=							"""cpu"""

          a__		:      Tuple					=							self.get_dummy_components()
          a__		:      Tuple					=							self.pipeline_class(**lowercase)
          pipe.to(lowercase)
          pipe.set_progress_bar_config(disable=lowercase)

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

          self.assertEqual(image.shape   ,    (1, 64, 64, 3))
          a__		:      int					=							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__		:      Any					=							np.abs(image_slice.flatten() - expected_slice).max()
          self.assertLessEqual(lowercase   ,    1e-3)

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







          '''simple docstring'''

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

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







          '''simple docstring'''

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

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







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		Tuple:







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		str:







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		str:







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		int:







          '''simple docstring'''

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





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




   """simple docstring"""



   @classmethod
   def 				__lowercase						(   cls)     ->		Any:







          '''simple docstring'''

          super().setUpClass()
          torch.use_deterministic_algorithms(lowercase)

   @classmethod
   def 				__lowercase						(   cls)     ->		str:







          '''simple docstring'''

          super().tearDownClass()
          torch.use_deterministic_algorithms(lowercase)

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







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		Dict:







          '''simple docstring'''

          a__		:      Dict					=							torch.manual_seed(51)

          a__		:      str					=							StableDiffusionAttendAndExcitePipeline.from_pretrained(
              'CompVis/stable-diffusion-v1-4'   ,    safety_checker=lowercase   ,    torch_dtype=torch.floataa)
          pipe.to('cuda')

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

          a__		:      List[Any]					=							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__		:      Tuple					=							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 transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments

def 				_snake_case      (   ):




   """simple docstring"""







   _lowerCamelCase	:					Any   =		HfArgumentParser(__snake_case   )
   _lowerCamelCase	:					int   =		parser.parse_args_into_dataclasses()[0]
   _lowerCamelCase	:					Dict   =		TensorFlowBenchmark(args=__snake_case   )
   try:
      _lowerCamelCase	:					Optional[int]   =		parser.parse_args_into_dataclasses()[0]
   except ValueError as e:
      _lowerCamelCase	:					Union[str, Any]   =		"""Arg --no_{0} is no longer used, please use --no-{0} instead."""
      _lowerCamelCase	:					List[str]   =		""" """.join(str(__snake_case   ).split(""" """   )[:-1]   )
      _lowerCamelCase	:					Dict   =		""""""
      _lowerCamelCase	:					List[Any]   =		eval(str(__snake_case   ).split(""" """   )[-1]   )
      _lowerCamelCase	:					Tuple   =		[]
      for arg in depreciated_args:
         # arg[2:] removes '--'
         if arg[2:] in TensorFlowBenchmark.deprecated_args:
            # arg[5:] removes '--no_'
            full_error_msg += arg_error_msg.format(arg[5:]   )
         else:
            wrong_args.append(__snake_case   )
      if len(__snake_case   ) > 0:
         _lowerCamelCase	:					Tuple   =		full_error_msg + begin_error_msg + str(__snake_case   )
      raise ValueError(__snake_case   )
   benchmark.run()


if __name__ == "__main__":
 main()

