


"""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


lowerCAmelCase__				    =       False


@skip_mps
class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   lowercase       ,   lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    Any       =StableDiffusionAttendAndExcitePipeline
       a  :    Tuple       =False
       a  :    Dict       =TEXT_TO_IMAGE_PARAMS
       a  :    Tuple       =TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}    )
       a  :    Union[str, Any]       =TEXT_TO_IMAGE_IMAGE_PARAMS
       a  :    List[str]       =TEXT_TO_IMAGE_IMAGE_PARAMS

       @classmethod
       def 	lowercase__							(						cls						):






         """simple docstring"""





         super().setUpClass()
         torch.use_deterministic_algorithms(snake_case__						)

       @classmethod
       def 	lowercase__							(						cls						):






         """simple docstring"""





         super().tearDownClass()
         torch.use_deterministic_algorithms(snake_case__						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)
         lowerCAmelCase					:					List[Any]								=							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=snake_case__		,					)
         lowerCAmelCase					:					Tuple								=							DDIMScheduler(
             beta_start=0.00085		,					beta_end=0.012		,					beta_schedule="scaled_linear"		,					clip_sample=snake_case__		,					set_alpha_to_one=snake_case__		,					)
         torch.manual_seed(0						)
         lowerCAmelCase					:					int								=							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						)
         lowerCAmelCase					:					int								=							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=1_000		,					hidden_act="gelu"		,					projection_dim=512		,					)
         lowerCAmelCase					:					str								=							CLIPTextModel(snake_case__						)
         lowerCAmelCase					:					Tuple								=							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

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

         return components

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__=0						):






         """simple docstring"""





         if str(snake_case__						).startswith("mps"						):
           lowerCAmelCase					:					Union[str, Any]								=							torch.manual_seed(snake_case__						)
         else:
           lowerCAmelCase					:					Dict								=							torch.Generator(device=snake_case__						).manual_seed(snake_case__						)
         lowerCAmelCase					:					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 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							"cpu"

         lowerCAmelCase					:					Tuple								=							self.get_dummy_components()
         lowerCAmelCase					:					Optional[int]								=							self.pipeline_class(**snake_case__						)
         pipe.to(snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					List[str]								=							self.get_dummy_inputs(snake_case__						)
         lowerCAmelCase					:					List[str]								=							pipe(**snake_case__						).images
         lowerCAmelCase					:					int								=							image[0, -3:, -3:, -1]

         self.assertEqual(image.shape		,					(1, 64, 64, 3)						)
         lowerCAmelCase					:					Union[str, Any]								=							np.array(
             [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]						)
         lowerCAmelCase					:					List[str]								=							np.abs(image_slice.flatten() - expected_slice						).max()
         self.assertLessEqual(snake_case__		,					1e-3						)

       def 	lowercase__							(						self						):






         """simple docstring"""





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

       def 	lowercase__							(						self						):






         """simple docstring"""





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

       def 	lowercase__							(						self						):






         """simple docstring"""





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

       def 	lowercase__							(						self						):






         """simple docstring"""





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

       def 	lowercase__							(						self						):






         """simple docstring"""





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

       def 	lowercase__							(						self						):






         """simple docstring"""





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







       def 	lowercase__							(						self						):






         """simple docstring"""





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


@require_torch_gpu
@slow
class 				SCREAMING_SNAKE_CASE__    (		unittest.TestCase    ):
       """simple docstring"""


       @classmethod
       def 	lowercase__							(						cls						):






         """simple docstring"""





         super().setUpClass()
         torch.use_deterministic_algorithms(snake_case__						)

       @classmethod
       def 	lowercase__							(						cls						):






         """simple docstring"""





         super().tearDownClass()
         torch.use_deterministic_algorithms(snake_case__						)

       def 	lowercase__							(						self						):






         """simple docstring"""





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







       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Union[str, Any]								=							torch.manual_seed(51						)

         lowerCAmelCase					:					Optional[Any]								=							StableDiffusionAttendAndExcitePipeline.from_pretrained(
             "CompVis/stable-diffusion-v1-4"		,					safety_checker=snake_case__		,					torch_dtype=torch.floataa						)
         pipe.to("cuda"						)

         lowerCAmelCase					:					Optional[Any]								=							"a painting of an elephant with glasses"
         lowerCAmelCase					:					Dict								=							[5, 7]

         lowerCAmelCase					:					Tuple								=							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[int]								=							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

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowerCAmelCase__				    =       {'''configuration_van''': ['''VAN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VanConfig''']}


try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase__				    =       [
         '''VAN_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''VanForImageClassification''',
         '''VanModel''',
         '''VanPreTrainedModel''',
     ]

if TYPE_CHECKING:
     from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_van import (
              VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
              VanForImageClassification,
              VanModel,
              VanPreTrainedModel,
          )

else:
     import sys

     lowerCAmelCase__				    =       _LazyModule(__name__, globals()['''__file__'''], _import_structure)





