



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

@skip_mps
class 							a__( lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			unittest.TestCase     ):
    lowercase__			=   StableDiffusionAttendAndExcitePipeline
    lowercase__			=   False
    lowercase__			=   TEXT_TO_IMAGE_PARAMS
    lowercase__			=   TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}     )
    lowercase__			=   TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase__			=   TEXT_TO_IMAGE_IMAGE_PARAMS







    @classmethod
    def       lowercase_	(				cls			:  Dict     ):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case     )







    @classmethod
    def       lowercase_	(				cls			:  str     ):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case     )







    def       lowercase_	(				self			:  Any     ):
      torch.manual_seed(0     )
      a						: Tuple					       =					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						,      )
      a						: List[str]					       =					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     )
      a						: List[Any]					       =					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=1_28						,      )
      torch.manual_seed(0     )
      a						: 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=10_00						,      hidden_act='gelu'						,      projection_dim=5_12						,      )
      a						: Dict					       =					CLIPTextModel(__snake_case     )
      a						: Optional[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			:  Optional[int]						,      __snake_case			:  Any						,      __snake_case			:  Optional[int]=0     ):
      if str(__snake_case     ).startswith('mps'     ):
        a						: int					       =					torch.manual_seed(__snake_case     )
      else:
        a						: Optional[int]					       =					torch.Generator(device=__snake_case     ).manual_seed(__snake_case     )
      a						: Optional[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			:  str     ):
      a						: Union[str, Any]					       =					'cpu'

      a						: Dict					       =					self.get_dummy_components()
      a						: Dict					       =					self.pipeline_class(**__snake_case     )
      pipe.to(__snake_case     )
      pipe.set_progress_bar_config(disable=__snake_case     )

      a						: str					       =					self.get_dummy_inputs(__snake_case     )
      a						: Optional[Any]					       =					pipe(**__snake_case     ).images
      a						: Optional[Any]					       =					image[0, -3:, -3:, -1]

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







    def       lowercase_	(				self			:  List[str]     ):
      super().test_cpu_offload_forward_pass(expected_max_diff=5e-4     )







    def       lowercase_	(				self			:  Optional[int]     ):
      # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
      self._test_inference_batch_consistent(batch_sizes=[1, 2]     )







    def       lowercase_	(				self			:  Optional[int]     ):
      self._test_inference_batch_single_identical(batch_size=2						,      expected_max_diff=7e-4     )







    def       lowercase_	(				self			:  List[str]     ):
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3     )







    def       lowercase_	(				self			:  List[Any]     ):
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4     )







    def       lowercase_	(				self			:  List[Any]     ):
      super().test_save_load_local(expected_max_difference=5e-4     )







    def       lowercase_	(				self			:  List[str]     ):
      super().test_save_load_optional_components(expected_max_difference=4e-4     )

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







    @classmethod
    def       lowercase_	(				cls			:  Dict     ):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case     )







    @classmethod
    def       lowercase_	(				cls			:  List[str]     ):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







    def       lowercase_	(				self			:  List[Any]     ):
      a						: Union[str, Any]					       =					torch.manual_seed(51     )

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

      a						: int					       =					'a painting of an elephant with glasses'
      a						: Union[str, Any]					       =					[5, 7]

      a						: 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]

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






import copy
import os

import cva
import numpy as np
from matplotlib import pyplot as plt

class 							a__:







    def __init__(				self			:  Optional[int]     ):
      a						: int					       =					''
      a						: List[str]					       =					''
      a						: int					       =					[]
      a						: Optional[Any]					       =					0
      a						: Optional[Any]					       =					2_56
      a						: int					       =					0
      a						: Optional[int]					       =					0
      a						: str					       =					0
      a						: int					       =					0







    def       lowercase_	(				self			:  List[str]						,      __snake_case			:  int     ):
      a						: Optional[Any]					       =					cva.imread(__snake_case						,      0     )
      a						: int					       =					copy.deepcopy(self.img     )
      a       ,     a       ,     a						: Optional[int]					       =					plt.hist(self.img.ravel()						,      2_56						,      [0, 2_56]						,      label='x'     )
      a						: str					       =					np.sum(__snake_case     )
      for i in range(len(__snake_case     )     ):
        a						: List[str]					       =					x[i] / self.k
        self.sk += prk
        a						: List[Any]					       =					(self.L - 1) * self.sk
        if self.rem != 0:
          a						: Union[str, Any]					       =					int(last % last     )
        a						: int					       =					int(last + 1 if self.rem >= 0.5 else last     )
        self.last_list.append(__snake_case     )
        a						: int					       =					int(np.ma.count(self.img     ) / self.img[1].size     )
        a						: Dict					       =					self.img[1].size
      for i in range(self.number_of_cols     ):
        for j in range(self.number_of_rows     ):
          a						: Tuple					       =					self.img[j][i]
          if num != self.last_list[num]:
            a						: Union[str, Any]					       =					self.last_list[num]
      cva.imwrite('output_data/output.jpg'						,      self.img     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      plt.hist(self.img.ravel()						,      2_56						,      [0, 2_56]     )







    def       lowercase_	(				self			:  Any     ):
      cva.imshow('Output-Image'						,      self.img     )
      cva.imshow('Input-Image'						,      self.original_image     )
      cva.waitKey(50_00     )
      cva.destroyAllWindows()


if __name__ == "__main__":
     lowerCAmelCase: Dict							=						os.path.join(os.path.basename(__file__), 'image_data/input.jpg')
     lowerCAmelCase: Optional[Any]							=						ConstantStretch()
     stretcher.stretch(file_path)
     stretcher.plot_histogram()
     stretcher.show_image()