code: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  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    __A       ( snake_case_,					snake_case_,					snake_case_,					unittest.TestCase    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						StableDiffusionModelEditingPipeline
   __lowerCAmelCase				      =						TEXT_TO_IMAGE_PARAMS
   __lowerCAmelCase				      =						TEXT_TO_IMAGE_BATCH_PARAMS
   __lowerCAmelCase				      =						TEXT_TO_IMAGE_IMAGE_PARAMS
   __lowerCAmelCase				      =						TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[Any]:
       torch.manual_seed(0		)
       a					=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				,					)
       a					=DDIMScheduler()
       torch.manual_seed(0		)
       a					=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		)
       a					=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				,					)
       a					=CLIPTextModel(__A		)
       a					=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
  
       a					={
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A				,					__A=0		)      ->  Optional[Any]:
       a					=torch.manual_seed(__A		)
       a					={
           '''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    SCREAMING_SNAKE_CASE							(	self		)      ->  List[Any]:
       a					='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a					=self.get_dummy_components()
       a					=StableDiffusionModelEditingPipeline(**__A		)
       a					=sd_pipe.to(__A		)
       sd_pipe.set_progress_bar_config(disable=__A		)
  
       a					=self.get_dummy_inputs(__A		)
       a					=sd_pipe(**__A		).images
       a					=image[0, -3:, -3:, -1]
       assert image.shape == (1, 64, 64, 3)
  
       a					=np.array([0.4_755, 0.5_132, 0.4_976, 0.3_904, 0.3_554, 0.4_765, 0.5_139, 0.5_158, 0.4_889]		)
  
       assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  str:
       a					='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a					=self.get_dummy_components()
       a					=StableDiffusionModelEditingPipeline(**__A		)
       a					=sd_pipe.to(__A		)
       sd_pipe.set_progress_bar_config(disable=__A		)
  
       a					=self.get_dummy_inputs(__A		)
       a					='''french fries'''
       a					=sd_pipe(**__A				,					negative_prompt=__A		)
       a					=output.images
       a					=image[0, -3:, -3:, -1]
  
       assert image.shape == (1, 64, 64, 3)
  
       a					=np.array([0.4_992, 0.5_101, 0.5_004, 0.3_949, 0.3_604, 0.4_735, 0.5_216, 0.5_204, 0.4_913]		)
  
       assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  List[str]:
       a					='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a					=self.get_dummy_components()
       a					=EulerAncestralDiscreteScheduler(
           beta_start=0.00_085				,					beta_end=0.012				,					beta_schedule='''scaled_linear'''		)
       a					=StableDiffusionModelEditingPipeline(**__A		)
       a					=sd_pipe.to(__A		)
       sd_pipe.set_progress_bar_config(disable=__A		)
  
       a					=self.get_dummy_inputs(__A		)
       a					=sd_pipe(**__A		).images
       a					=image[0, -3:, -3:, -1]
  
       assert image.shape == (1, 64, 64, 3)
  
       a					=np.array([0.4_747, 0.5_372, 0.4_779, 0.4_982, 0.5_543, 0.4_816, 0.5_238, 0.4_904, 0.5_027]		)
  
       assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[Any]:
       a					='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a					=self.get_dummy_components()
       a					=PNDMScheduler()
       a					=StableDiffusionModelEditingPipeline(**__A		)
       a					=sd_pipe.to(__A		)
       sd_pipe.set_progress_bar_config(disable=__A		)
  
       a					=self.get_dummy_inputs(__A		)
       # the pipeline does not expect pndm so test if it raises error.
       with self.assertRaises(__A		):
           a					=sd_pipe(**__A		).images
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Tuple:
       super().test_inference_batch_single_identical(expected_max_diff=5E-3		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  str:
       super().test_attention_slicing_forward_pass(expected_max_diff=5E-3		)
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class    __A       ( unittest.TestCase    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  str:
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A=0		)      ->  int:
       a					=torch.manual_seed(__A		)
       a					={
           '''prompt''': '''A field of roses''',
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  int:
       a					='''CompVis/stable-diffusion-v1-4'''
       a					=StableDiffusionModelEditingPipeline.from_pretrained(__A				,					safety_checker=__A		)
       pipe.to(__A		)
       pipe.set_progress_bar_config(disable=__A		)
       pipe.enable_attention_slicing()
  
       a					=self.get_inputs()
       a					=pipe(**__A		).images
       a					=image[0, -3:, -3:, -1].flatten()
  
       assert image.shape == (1, 512, 512, 3)
  
       a					=np.array(
           [0.6_749_496, 0.6_386_453, 0.51_443_267, 0.66_094_905, 0.61_921_215, 0.5_491_332, 0.5_744_417, 0.58_075_106, 0.5_174_658]		)
  
       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'''		)
  
       a					=pipe(**__A		).images
       a					=image[0, -3:, -3:, -1].flatten()
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(expected_slice - image_slice		).max() > 1E-1
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[Any]:
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()
  
       a					='''CompVis/stable-diffusion-v1-4'''
       a					=DDIMScheduler.from_pretrained(__A				,					subfolder='''scheduler'''		)
       a					=StableDiffusionModelEditingPipeline.from_pretrained(
           __A				,					scheduler=__A				,					safety_checker=__A		)
       a					=pipe.to(__A		)
       pipe.set_progress_bar_config(disable=__A		)
       pipe.enable_attention_slicing(1		)
       pipe.enable_sequential_cpu_offload()
  
       a					=self.get_inputs()
       a					=pipe(**__A		)
  
       a					=torch.cuda.max_memory_allocated()
       # make sure that less than 4.4 GB is allocated
       assert mem_bytes < 4.4 * 10**9
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  lowerCamelCase_     :     Any    		=						{"""configuration_dinat""": ["""DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DinatConfig"""]}
  
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         lowerCamelCase_     :     List[str]    		=						[
             """DINAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
             """DinatForImageClassification""",
             """DinatModel""",
             """DinatPreTrainedModel""",
             """DinatBackbone""",
         ]
  
  if TYPE_CHECKING:
         from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_dinat import (
                    DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                    DinatBackbone,
                    DinatForImageClassification,
                    DinatModel,
                    DinatPreTrainedModel,
                )
  
  else:
         import sys
  
         lowerCamelCase_     :     List[Any]    		=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)