code: 
  
  
  
  
  
  
  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 (    UpperCamelCase				,				UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       Optional[int]   =   StableDiffusionModelEditingPipeline
      lowerCamelCase  :       Optional[Any]   =   TEXT_TO_IMAGE_PARAMS
      lowerCamelCase  :       Optional[Any]   =   TEXT_TO_IMAGE_BATCH_PARAMS
      lowerCamelCase  :       Dict   =   TEXT_TO_IMAGE_IMAGE_PARAMS
      lowerCamelCase  :       Tuple   =   TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
      def _a       (							self			:    Optional[int]			)			->       str:
             torch.manual_seed(0			)
             __UpperCAmelCase    							=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    							=DDIMScheduler()
             torch.manual_seed(0			)
             __UpperCAmelCase    							=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    							=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=1000   ,    )
             __UpperCAmelCase    							=CLIPTextModel(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
             __UpperCAmelCase    							={
                 """unet""": unet,
                 """scheduler""": scheduler,
                 """vae""": vae,
                 """text_encoder""": text_encoder,
                 """tokenizer""": tokenizer,
                 """safety_checker""": None,
                 """feature_extractor""": None,
             }
             return components
  
  
  
      def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    str   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=0			)			->       Tuple:
             __UpperCAmelCase    							=torch.manual_seed(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							={
                 """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 _a       (							self			:    str			)			->       Any:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.get_dummy_components()
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline(**__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe.to(__SCREAMING_SNAKE_CASE			)
             sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=self.get_dummy_inputs(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe(**__SCREAMING_SNAKE_CASE			).images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             assert image.shape == (1, 64, 64, 3)
  
             __UpperCAmelCase    							=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 _a       (							self			:    Union[str, Any]			)			->       str:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.get_dummy_components()
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline(**__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe.to(__SCREAMING_SNAKE_CASE			)
             sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=self.get_dummy_inputs(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							="""french fries"""
             __UpperCAmelCase    							=sd_pipe(**__SCREAMING_SNAKE_CASE   ,    negative_prompt=__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
  
             assert image.shape == (1, 64, 64, 3)
  
             __UpperCAmelCase    							=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 _a       (							self			:    Union[str, Any]			)			->       Optional[int]:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.get_dummy_components()
             __UpperCAmelCase    							=EulerAncestralDiscreteScheduler(
                 beta_start=0.00_085   ,    beta_end=0.012   ,    beta_schedule="""scaled_linear"""			)
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline(**__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe.to(__SCREAMING_SNAKE_CASE			)
             sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=self.get_dummy_inputs(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe(**__SCREAMING_SNAKE_CASE			).images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
  
             assert image.shape == (1, 64, 64, 3)
  
             __UpperCAmelCase    							=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 _a       (							self			:    int			)			->       int:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.get_dummy_components()
             __UpperCAmelCase    							=PNDMScheduler()
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline(**__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=sd_pipe.to(__SCREAMING_SNAKE_CASE			)
             sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=self.get_dummy_inputs(__SCREAMING_SNAKE_CASE			)
             # the pipeline does not expect pndm so test if it raises error.
             with self.assertRaises(__SCREAMING_SNAKE_CASE			):
                    __UpperCAmelCase    							=sd_pipe(**__SCREAMING_SNAKE_CASE			).images
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       List[Any]:
             super().test_inference_batch_single_identical(expected_max_diff=5e-3			)
  
  
  
      def _a       (							self			:    Tuple			)			->       Dict:
             super().test_attention_slicing_forward_pass(expected_max_diff=5e-3			)
  
  
  
  
  @slow
  @require_torch_gpu
  class 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      def _a       (							self			:    Optional[int]			)			->       Dict:
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
  
  
  
      def _a       (							self			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    Tuple=0			)			->       List[Any]:
             __UpperCAmelCase    							=torch.manual_seed(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							={
                 """prompt""": """A field of roses""",
                 """generator""": generator,
                 """num_inference_steps""": 3,
                 """guidance_scale""": 7.5,
                 """output_type""": """numpy""",
             }
             return inputs
  
  
  
      def _a       (							self			:    Optional[int]			)			->       Dict:
             __UpperCAmelCase    							="""CompVis/stable-diffusion-v1-4"""
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline.from_pretrained(__SCREAMING_SNAKE_CASE   ,    safety_checker=__SCREAMING_SNAKE_CASE			)
             pipe.to(__SCREAMING_SNAKE_CASE			)
             pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
             pipe.enable_attention_slicing()
  
             __UpperCAmelCase    							=self.get_inputs()
             __UpperCAmelCase    							=pipe(**__SCREAMING_SNAKE_CASE			).images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1].flatten()
  
             assert image.shape == (1, 512, 512, 3)
  
             __UpperCAmelCase    							=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"""			)
  
             __UpperCAmelCase    							=pipe(**__SCREAMING_SNAKE_CASE			).images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1].flatten()
  
             assert image.shape == (1, 512, 512, 3)
  
             assert np.abs(expected_slice - image_slice			).max() > 1e-1
  
  
  
      def _a       (							self			:    Any			)			->       Union[str, Any]:
             torch.cuda.empty_cache()
             torch.cuda.reset_max_memory_allocated()
             torch.cuda.reset_peak_memory_stats()
  
             __UpperCAmelCase    							="""CompVis/stable-diffusion-v1-4"""
             __UpperCAmelCase    							=DDIMScheduler.from_pretrained(__SCREAMING_SNAKE_CASE   ,    subfolder="""scheduler"""			)
             __UpperCAmelCase    							=StableDiffusionModelEditingPipeline.from_pretrained(
                 __SCREAMING_SNAKE_CASE   ,    scheduler=__SCREAMING_SNAKE_CASE   ,    safety_checker=__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=pipe.to(__SCREAMING_SNAKE_CASE			)
             pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)
             pipe.enable_attention_slicing(1			)
             pipe.enable_sequential_cpu_offload()
  
             __UpperCAmelCase    							=self.get_inputs()
             __UpperCAmelCase    							=pipe(**__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=torch.cuda.max_memory_allocated()
             # make sure that less than 4.4 GB is allocated
             assert mem_bytes < 4.4 * 10**9
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  __A  							=  [0.485, 0.456, 0.406]
  __A  							=  [0.229, 0.224, 0.225]
  __A  							=  [0.5, 0.5, 0.5]
  __A  							=  [0.5, 0.5, 0.5]
  __A  							=  [0.4814_5466, 0.457_8275, 0.4082_1073]
  __A  							=  [0.2686_2954, 0.2613_0258, 0.2757_7711]
  
  
  
  
  