


'''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__:    Optional[Any]					    =       False







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






      @classmethod
      def __UpperCAmelCase       ( cls			:int	)       ->					Any:




             '''simple docstring'''
             super().setUpClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE	)






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




             '''simple docstring'''
             super().tearDownClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Dict	)       ->					int:




             '''simple docstring'''
             torch.manual_seed(0	)
             _a    : Any     					=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=SCREAMING_SNAKE_CASE     ,						)
             _a    : Optional[int]     					=DDIMScheduler(
                 beta_start=0.00_085     ,						beta_end=0.012     ,						beta_schedule="""scaled_linear"""     ,						clip_sample=SCREAMING_SNAKE_CASE     ,						set_alpha_to_one=SCREAMING_SNAKE_CASE     ,						)
             torch.manual_seed(0	)
             _a    : 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	)
             _a    : Any     					=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     ,						)
             _a    : Dict     					=CLIPTextModel(SCREAMING_SNAKE_CASE	)
             _a    : int     					=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

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

             return components






      def __UpperCAmelCase       ( self			:Any     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:int=0	)       ->					str:




             '''simple docstring'''
             if str(SCREAMING_SNAKE_CASE	).startswith("""mps"""	):
                    _a    : Any     					=torch.manual_seed(SCREAMING_SNAKE_CASE	)
             else:
                    _a    : Dict     					=torch.Generator(device=SCREAMING_SNAKE_CASE	).manual_seed(SCREAMING_SNAKE_CASE	)
             _a    : List[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 __UpperCAmelCase       ( self			:Dict	)       ->					str:




             '''simple docstring'''
             _a    : List[str]     					="""cpu"""

             _a    : Union[str, Any]     					=self.get_dummy_components()
             _a    : Tuple     					=self.pipeline_class(**SCREAMING_SNAKE_CASE	)
             pipe.to(SCREAMING_SNAKE_CASE	)
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE	)

             _a    : Optional[Any]     					=self.get_dummy_inputs(SCREAMING_SNAKE_CASE	)
             _a    : Optional[Any]     					=pipe(**SCREAMING_SNAKE_CASE	).images
             _a    : int     					=image[0, -3:, -3:, -1]

             self.assertEqual(image.shape     ,						(1, 6_4, 6_4, 3)	)
             _a    : List[Any]     					=np.array(
                 [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496]	)
             _a    : Tuple     					=np.abs(image_slice.flatten() - expected_slice	).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE     ,						1e-3	)






      def __UpperCAmelCase       ( self			:Optional[Any]	)       ->					List[Any]:




             '''simple docstring'''
             super().test_cpu_offload_forward_pass(expected_max_diff=5e-4	)






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




             '''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 __UpperCAmelCase       ( self			:List[Any]	)       ->					int:




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






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




             '''simple docstring'''
             super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3	)






      def __UpperCAmelCase       ( self			:Optional[int]	)       ->					int:




             '''simple docstring'''
             super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4	)






      def __UpperCAmelCase       ( self			:Optional[int]	)       ->					Any:




             '''simple docstring'''
             super().test_save_load_local(expected_max_difference=5e-4	)






      def __UpperCAmelCase       ( self			:Tuple	)       ->					Any:




             '''simple docstring'''
             super().test_save_load_optional_components(expected_max_difference=4e-4	)







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






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




             '''simple docstring'''
             super().setUpClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE	)






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




             '''simple docstring'''
             super().tearDownClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE	)






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




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






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




             '''simple docstring'''
             _a    : Any     					=torch.manual_seed(5_1	)

             _a    : str     					=StableDiffusionAttendAndExcitePipeline.from_pretrained(
                 """CompVis/stable-diffusion-v1-4"""     ,						safety_checker=SCREAMING_SNAKE_CASE     ,						torch_dtype=torch.floataa	)
             pipe.to("""cuda"""	)

             _a    : List[str]     					="""a painting of an elephant with glasses"""
             _a    : Dict     					=[5, 7]

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

             _a    : str     					=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'''







A__:    Tuple					    =       '''
# Installazione di Transformers
! pip install transformers datasets
# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e
# rimuovi la modalità commento al comando seguente.
# ! pip install git+https://github.com/huggingface/transformers.git
'''

A__:    Tuple					    =       [{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
A__:    Any					    =       {
    '''{processor_class}''': '''FakeProcessorClass''',
    '''{model_class}''': '''FakeModelClass''',
    '''{object_class}''': '''FakeObjectClass''',
}


