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 						snake_case			(       lowerCAmelCase__	, lowerCAmelCase__	, lowerCAmelCase__	, unittest.TestCase	):
  			'''simple docstring'''
  
  			UpperCAmelCase       :       Tuple       = StableDiffusionModelEditingPipeline
  			UpperCAmelCase       :       Optional[Any]       = TEXT_TO_IMAGE_PARAMS
  			UpperCAmelCase       :       str       = TEXT_TO_IMAGE_BATCH_PARAMS
  			UpperCAmelCase       :       Union[str, Any]       = TEXT_TO_IMAGE_IMAGE_PARAMS
  			UpperCAmelCase       :       Any       = TEXT_TO_IMAGE_IMAGE_PARAMS
  
  			def _lowercase (	self     :     Optional[int]					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								torch.manual_seed(0					)
  								SCREAMING_SNAKE_CASE_	      =       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							,							)
  								SCREAMING_SNAKE_CASE_	      =       DDIMScheduler()
  								torch.manual_seed(0					)
  								SCREAMING_SNAKE_CASE_	      =       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					)
  								SCREAMING_SNAKE_CASE_	      =       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							,							)
  								SCREAMING_SNAKE_CASE_	      =       CLIPTextModel(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
  
  								SCREAMING_SNAKE_CASE_	      =       {
  								    '''unet''': unet,
  								    '''scheduler''': scheduler,
  								    '''vae''': vae,
  								    '''text_encoder''': text_encoder,
  								    '''tokenizer''': tokenizer,
  								    '''safety_checker''': None,
  								    '''feature_extractor''': None,
  								}
  								return components
  
  			def _lowercase (	self     :     int							,							lowerCAmelCase_     :     Tuple							,							lowerCAmelCase_     :     int=0					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       torch.manual_seed(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       {
  								    '''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 _lowercase (	self     :     int					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_components()
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline(**lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe.to(lowerCAmelCase_					)
  								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe(**lowerCAmelCase_					).images
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1]
  								assert image.shape == (1, 64, 64, 3)
  
  								SCREAMING_SNAKE_CASE_	      =       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 _lowercase (	self     :     Optional[Any]					)					->					Tuple:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_components()
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline(**lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe.to(lowerCAmelCase_					)
  								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       '''french fries'''
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe(**lowerCAmelCase_							,							negative_prompt=lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       output.images
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 64, 64, 3)
  
  								SCREAMING_SNAKE_CASE_	      =       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 _lowercase (	self     :     int					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_components()
  								SCREAMING_SNAKE_CASE_	      =       EulerAncestralDiscreteScheduler(
  								    beta_start=0.00_085							,							beta_end=0.012							,							beta_schedule='''scaled_linear'''					)
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline(**lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe.to(lowerCAmelCase_					)
  								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe(**lowerCAmelCase_					).images
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 64, 64, 3)
  
  								SCREAMING_SNAKE_CASE_	      =       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 _lowercase (	self     :     Optional[Any]					)					->					Tuple:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_components()
  								SCREAMING_SNAKE_CASE_	      =       PNDMScheduler()
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline(**lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       sd_pipe.to(lowerCAmelCase_					)
  								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs(lowerCAmelCase_					)
  								# the pipeline does not expect pndm so test if it raises error.
  								with self.assertRaises(lowerCAmelCase_					):
  													SCREAMING_SNAKE_CASE_	      =       sd_pipe(**lowerCAmelCase_					).images
  
  			def _lowercase (	self     :     Tuple					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								super().test_inference_batch_single_identical(expected_max_diff=5e-3					)
  
  
  
  
  			def _lowercase (	self     :     List[str]					)					->					Tuple:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								super().test_attention_slicing_forward_pass(expected_max_diff=5e-3					)
  
  @slow
  @require_torch_gpu
  class 						snake_case			(       unittest.TestCase	):
  			'''simple docstring'''
  
  			def _lowercase (	self     :     Optional[int]					)					->					Optional[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								super().tearDown()
  								gc.collect()
  								torch.cuda.empty_cache()
  
  			def _lowercase (	self     :     int							,							lowerCAmelCase_     :     Optional[int]=0					)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       torch.manual_seed(lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       {
  								    '''prompt''': '''A field of roses''',
  								    '''generator''': generator,
  								    '''num_inference_steps''': 3,
  								    '''guidance_scale''': 7.5,
  								    '''output_type''': '''numpy''',
  								}
  								return inputs
  
  			def _lowercase (	self     :     Optional[Any]					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       '''CompVis/stable-diffusion-v1-4'''
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline.from_pretrained(lowerCAmelCase_							,							safety_checker=lowerCAmelCase_					)
  								pipe.to(lowerCAmelCase_					)
  								pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  								pipe.enable_attention_slicing()
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_inputs()
  								SCREAMING_SNAKE_CASE_	      =       pipe(**lowerCAmelCase_					).images
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1].flatten()
  
  								assert image.shape == (1, 512, 512, 3)
  
  								SCREAMING_SNAKE_CASE_	      =       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'''					)
  
  								SCREAMING_SNAKE_CASE_	      =       pipe(**lowerCAmelCase_					).images
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1].flatten()
  
  								assert image.shape == (1, 512, 512, 3)
  
  								assert np.abs(expected_slice - image_slice					).max() > 1e-1
  
  
  
  
  			def _lowercase (	self     :     Union[str, Any]					)					->					Optional[int]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								torch.cuda.empty_cache()
  								torch.cuda.reset_max_memory_allocated()
  								torch.cuda.reset_peak_memory_stats()
  
  								SCREAMING_SNAKE_CASE_	      =       '''CompVis/stable-diffusion-v1-4'''
  								SCREAMING_SNAKE_CASE_	      =       DDIMScheduler.from_pretrained(lowerCAmelCase_							,							subfolder='''scheduler'''					)
  								SCREAMING_SNAKE_CASE_	      =       StableDiffusionModelEditingPipeline.from_pretrained(
  								    lowerCAmelCase_							,							scheduler=lowerCAmelCase_							,							safety_checker=lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       pipe.to(lowerCAmelCase_					)
  								pipe.set_progress_bar_config(disable=lowerCAmelCase_					)
  								pipe.enable_attention_slicing(1					)
  								pipe.enable_sequential_cpu_offload()
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_inputs()
  								SCREAMING_SNAKE_CASE_	      =       pipe(**lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       torch.cuda.max_memory_allocated()
  								# make sure that less than 4.4 GB is allocated
  								assert mem_bytes < 4.4 * 10**9
  
  
  
style_context: 
  
  
  def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase      )->		int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					return (input_a, input_a).count(0      ) % 2
  
  
  
  
  
  
  
  def 							UpperCAmelCase				(     )->		None:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					assert xor_gate(0				,0      ) == 0
  					assert xor_gate(0				,1      ) == 1
  					assert xor_gate(1				,0      ) == 1
  					assert xor_gate(1				,1      ) == 0
  
  
  if __name__ == "__main__":
  		print(xor_gate(0, 0))
  		print(xor_gate(0, 1))
  
  
  