


import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()

@skip_mps
class    __magic_name__						(  __lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					unittest.TestCase):
     A:		Union[str, Any]								=   StableDiffusionModelEditingPipeline
     A:		Any								=   TEXT_TO_IMAGE_PARAMS
     A:		Optional[int]								=   TEXT_TO_IMAGE_BATCH_PARAMS
     A:		Any								=   TEXT_TO_IMAGE_IMAGE_PARAMS
     A:		str								=   TEXT_TO_IMAGE_IMAGE_PARAMS


     def   UpperCAmelCase__						(   self				:  str      )	->   Optional[int]:





      '''simple docstring'''






      torch.manual_seed(0      )
      UpperCamelCase__       :     int 							= UNetaDConditionModel(
          block_out_channels=(32, 64)				,						layers_per_block=2				,						sample_size=32				,						in_channels=4				,						out_channels=4				,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')				,						cross_attention_dim=32				,						)
      UpperCamelCase__       :     Dict 							= DDIMScheduler()
      torch.manual_seed(0      )
      UpperCamelCase__       :     Tuple 							= 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				,						)
      torch.manual_seed(0      )
      UpperCamelCase__       :     List[Any] 							= 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				,						)
      UpperCamelCase__       :     Union[str, Any] 							= CLIPTextModel(lowerCamelCase__      )
      UpperCamelCase__       :     Tuple 							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

      UpperCamelCase__       :     Dict 							= {
          '''unet''': unet,
          '''scheduler''': scheduler,
          '''vae''': vae,
          '''text_encoder''': text_encoder,
          '''tokenizer''': tokenizer,
          '''safety_checker''': None,
          '''feature_extractor''': None,
      }
      return components


     def   UpperCAmelCase__						(   self				:  Dict				,						lowerCamelCase__				:  Optional[int]				,						lowerCamelCase__				:  str=0      )	->   Optional[int]:





      '''simple docstring'''






      UpperCamelCase__       :     Optional[int] 							= torch.manual_seed(lowerCamelCase__      )
      UpperCamelCase__       :     Union[str, Any] 							= {
          '''prompt''': '''A field of roses''',
          '''generator''': generator,
          # Setting height and width to None to prevent OOMs on CPU.
          '''height''': None,
          '''width''': None,
          '''num_inference_steps''': 2,
          '''guidance_scale''': 6.0,
          '''output_type''': '''numpy''',
      }
      return inputs


     def   UpperCAmelCase__						(   self				:  Dict      )	->   Any:





      '''simple docstring'''






      UpperCamelCase__       :     List[str] 							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
      UpperCamelCase__       :     Tuple 							= self.get_dummy_components()
      UpperCamelCase__       :     int 							= StableDiffusionModelEditingPipeline(**lowerCamelCase__      )
      UpperCamelCase__       :     List[str] 							= sd_pipe.to(lowerCamelCase__      )
      sd_pipe.set_progress_bar_config(disable=lowerCamelCase__      )

      UpperCamelCase__       :     Optional[Any] 							= self.get_dummy_inputs(lowerCamelCase__      )
      UpperCamelCase__       :     List[str] 							= sd_pipe(**lowerCamelCase__      ).images
      UpperCamelCase__       :     Union[str, Any] 							= image[0, -3:, -3:, -1]
      assert image.shape == (1, 64, 64, 3)

      UpperCamelCase__       :     Dict 							= np.array([0.4755, 0.5132, 0.4976, 0.3904, 0.3554, 0.4765, 0.5139, 0.5158, 0.4889]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2


     def   UpperCAmelCase__						(   self				:  Optional[Any]      )	->   Tuple:





      '''simple docstring'''






      UpperCamelCase__       :     Any 							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
      UpperCamelCase__       :     Union[str, Any] 							= self.get_dummy_components()
      UpperCamelCase__       :     int 							= StableDiffusionModelEditingPipeline(**lowerCamelCase__      )
      UpperCamelCase__       :     Optional[int] 							= sd_pipe.to(lowerCamelCase__      )
      sd_pipe.set_progress_bar_config(disable=lowerCamelCase__      )

      UpperCamelCase__       :     List[Any] 							= self.get_dummy_inputs(lowerCamelCase__      )
      UpperCamelCase__       :     int 							= '''french fries'''
      UpperCamelCase__       :     int 							= sd_pipe(**lowerCamelCase__				,						negative_prompt=lowerCamelCase__      )
      UpperCamelCase__       :     Any 							= output.images
      UpperCamelCase__       :     Tuple 							= image[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)

      UpperCamelCase__       :     Union[str, Any] 							= np.array([0.4992, 0.5101, 0.5004, 0.3949, 0.3604, 0.4735, 0.5216, 0.5204, 0.4913]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2


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





      '''simple docstring'''






      UpperCamelCase__       :     Any 							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
      UpperCamelCase__       :     Dict 							= self.get_dummy_components()
      UpperCamelCase__       :     List[Any] 							= EulerAncestralDiscreteScheduler(
          beta_start=0.0_0085				,						beta_end=0.012				,						beta_schedule='''scaled_linear'''      )
      UpperCamelCase__       :     Dict 							= StableDiffusionModelEditingPipeline(**lowerCamelCase__      )
      UpperCamelCase__       :     int 							= sd_pipe.to(lowerCamelCase__      )
      sd_pipe.set_progress_bar_config(disable=lowerCamelCase__      )

      UpperCamelCase__       :     Optional[int] 							= self.get_dummy_inputs(lowerCamelCase__      )
      UpperCamelCase__       :     Tuple 							= sd_pipe(**lowerCamelCase__      ).images
      UpperCamelCase__       :     str 							= image[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)

      UpperCamelCase__       :     Tuple 							= np.array([0.4747, 0.5372, 0.4779, 0.4982, 0.5543, 0.4816, 0.5238, 0.4904, 0.5027]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2


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





      '''simple docstring'''






      UpperCamelCase__       :     Optional[Any] 							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
      UpperCamelCase__       :     str 							= self.get_dummy_components()
      UpperCamelCase__       :     int 							= PNDMScheduler()
      UpperCamelCase__       :     List[Any] 							= StableDiffusionModelEditingPipeline(**lowerCamelCase__      )
      UpperCamelCase__       :     Dict 							= sd_pipe.to(lowerCamelCase__      )
      sd_pipe.set_progress_bar_config(disable=lowerCamelCase__      )

      UpperCamelCase__       :     Tuple 							= self.get_dummy_inputs(lowerCamelCase__      )
      # the pipeline does not expect pndm so test if it raises error.
      with self.assertRaises(lowerCamelCase__      ):
       UpperCamelCase__       :     Optional[int] 							= sd_pipe(**lowerCamelCase__      ).images


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





      '''simple docstring'''






      super().test_inference_batch_single_identical(expected_max_diff=5E-3      )


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





      '''simple docstring'''






      super().test_attention_slicing_forward_pass(expected_max_diff=5E-3      )



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


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





      '''simple docstring'''






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


     def   UpperCAmelCase__						(   self				:  Union[str, Any]				,						lowerCamelCase__				:  List[Any]=0      )	->   Optional[int]:





      '''simple docstring'''






      UpperCamelCase__       :     Optional[Any] 							= torch.manual_seed(lowerCamelCase__      )
      UpperCamelCase__       :     Tuple 							= {
          '''prompt''': '''A field of roses''',
          '''generator''': generator,
          '''num_inference_steps''': 3,
          '''guidance_scale''': 7.5,
          '''output_type''': '''numpy''',
      }
      return inputs


     def   UpperCAmelCase__						(   self				:  Dict      )	->   Optional[Any]:





      '''simple docstring'''






      UpperCamelCase__       :     Union[str, Any] 							= '''CompVis/stable-diffusion-v1-4'''
      UpperCamelCase__       :     str 							= StableDiffusionModelEditingPipeline.from_pretrained(lowerCamelCase__				,						safety_checker=lowerCamelCase__      )
      pipe.to(lowerCamelCase__      )
      pipe.set_progress_bar_config(disable=lowerCamelCase__      )
      pipe.enable_attention_slicing()

      UpperCamelCase__       :     Optional[Any] 							= self.get_inputs()
      UpperCamelCase__       :     List[Any] 							= pipe(**lowerCamelCase__      ).images
      UpperCamelCase__       :     Dict 							= image[0, -3:, -3:, -1].flatten()

      assert image.shape == (1, 512, 512, 3)

      UpperCamelCase__       :     List[str] 							= np.array(
          [0.674_9496, 0.638_6453, 0.5144_3267, 0.6609_4905, 0.6192_1215, 0.549_1332, 0.574_4417, 0.5807_5106, 0.517_4658]      )

      assert np.abs(expected_slice - image_slice      ).max() < 1E-2

      # make sure image changes after editing
      pipe.edit_model('''A pack of roses'''				,						'''A pack of blue roses'''      )

      UpperCamelCase__       :     str 							= pipe(**lowerCamelCase__      ).images
      UpperCamelCase__       :     Union[str, Any] 							= image[0, -3:, -3:, -1].flatten()

      assert image.shape == (1, 512, 512, 3)

      assert np.abs(expected_slice - image_slice      ).max() > 1E-1


     def   UpperCAmelCase__						(   self				:  Any      )	->   str:





      '''simple docstring'''






      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()

      UpperCamelCase__       :     Union[str, Any] 							= '''CompVis/stable-diffusion-v1-4'''
      UpperCamelCase__       :     str 							= DDIMScheduler.from_pretrained(lowerCamelCase__				,						subfolder='''scheduler'''      )
      UpperCamelCase__       :     str 							= StableDiffusionModelEditingPipeline.from_pretrained(
          lowerCamelCase__				,						scheduler=lowerCamelCase__				,						safety_checker=lowerCamelCase__      )
      UpperCamelCase__       :     List[Any] 							= pipe.to(lowerCamelCase__      )
      pipe.set_progress_bar_config(disable=lowerCamelCase__      )
      pipe.enable_attention_slicing(1      )
      pipe.enable_sequential_cpu_offload()

      UpperCamelCase__       :     List[str] 							= self.get_inputs()
      UpperCamelCase__       :     Optional[Any] 							= pipe(**lowerCamelCase__      )

      UpperCamelCase__       :     List[str] 							= torch.cuda.max_memory_allocated()
      # make sure that less than 4.4 GB is allocated
      assert mem_bytes < 4.4 * 10**9






import numpy as np

def       _a	(					SCREAMING_SNAKE_CASE						:					Tuple  ):







 """simple docstring"""



 UpperCamelCase__       :     str 							= np.exp(SCREAMING_SNAKE_CASE  )

 # Add up the all the exponentials
 UpperCamelCase__       :     Optional[int] 							= np.sum(SCREAMING_SNAKE_CASE  )

 # Divide every exponent by the sum of all exponents
 UpperCamelCase__       :     Optional[Any] 							= exponent_vector / sum_of_exponents

 return softmax_vector


if __name__ == "__main__":
       print(softmax((0,)))


