code: import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
  from diffusers.utils import floats_tensor, nightly, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  
  enable_full_determinism()
  
  
  
  
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().tearDown()
  							gc.collect()
  							torch.cuda.empty_cache()
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     1
  							__snake_case		       =     3
  							__snake_case		       =     (32, 32)
  
  							__snake_case		       =     floats_tensor((batch_size, num_channels) + sizes      ,rng=random.Random(0						)						).to(_lowerCAmelCase						)
  							return image
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							torch.manual_seed(0						)
  							__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      ,)
  							return model
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							torch.manual_seed(0						)
  							__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      ,)
  							return model
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							torch.manual_seed(0						)
  							__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      ,)
  							return CLIPTextModel(_lowerCAmelCase						)
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							def extract(*_lowerCAmelCase :					List[Any]      ,**_lowerCAmelCase :					Dict						):
  
  
  
  
  									class 					UpperCamelCase	:
  
  
  
  
  														def __init__( self :					Dict						):
  
  
  																"""simple docstring"""
  
  
  
  
  																__snake_case		       =     torch.ones([0]						)
  
  
  
  
  
  
  
  														def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Optional[Any]						):
  
  
  																"""simple docstring"""
  
  
  
  
  																self.pixel_values.to(_lowerCAmelCase						)
  																return self
  
  
  
  
  									return Out()
  
  							return extract
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cpu"  # ensure determinism for the device-dependent torch.Generator
  							__snake_case		       =     self.dummy_cond_unet
  							__snake_case		       =     DDIMScheduler(
  							    beta_start=0.0_0_0_8_5      ,beta_end=0.0_1_2      ,beta_schedule="scaled_linear"      ,clip_sample=_lowerCAmelCase      ,set_alpha_to_one=_lowerCAmelCase      ,)
  
  							__snake_case		       =     self.dummy_vae
  							__snake_case		       =     self.dummy_text_encoder
  							__snake_case		       =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)
  
  							# make sure here that pndm scheduler skips prk
  							__snake_case		       =     StableDiffusionPipeline(
  							    unet=_lowerCAmelCase      ,scheduler=_lowerCAmelCase      ,vae=_lowerCAmelCase      ,text_encoder=_lowerCAmelCase      ,tokenizer=_lowerCAmelCase      ,safety_checker=_lowerCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
  							__snake_case		       =     sd_pipe.to(_lowerCAmelCase						)
  							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "A painting of a squirrel eating a burger"
  
  							__snake_case		       =     torch.Generator(device=_lowerCAmelCase						).manual_seed(0						)
  							__snake_case		       =     sd_pipe([prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type="np"						)
  							__snake_case		       =     output.images
  
  							__snake_case		       =     torch.Generator(device=_lowerCAmelCase						).manual_seed(0						)
  							__snake_case		       =     sd_pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type="np"      ,return_dict=_lowerCAmelCase      ,)[0]
  
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     image_from_tuple[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 64, 64, 3)
  							__snake_case		       =     np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7]						)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  							assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cpu"  # ensure determinism for the device-dependent torch.Generator
  							__snake_case		       =     self.dummy_cond_unet
  							__snake_case		       =     PNDMScheduler(skip_prk_steps=_lowerCAmelCase						)
  							__snake_case		       =     self.dummy_vae
  							__snake_case		       =     self.dummy_text_encoder
  							__snake_case		       =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)
  
  							# make sure here that pndm scheduler skips prk
  							__snake_case		       =     StableDiffusionPipeline(
  							    unet=_lowerCAmelCase      ,scheduler=_lowerCAmelCase      ,vae=_lowerCAmelCase      ,text_encoder=_lowerCAmelCase      ,tokenizer=_lowerCAmelCase      ,safety_checker=_lowerCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
  							__snake_case		       =     sd_pipe.to(_lowerCAmelCase						)
  							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "A painting of a squirrel eating a burger"
  							__snake_case		       =     torch.Generator(device=_lowerCAmelCase						).manual_seed(0						)
  							__snake_case		       =     sd_pipe([prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type="np"						)
  
  							__snake_case		       =     output.images
  
  							__snake_case		       =     torch.Generator(device=_lowerCAmelCase						).manual_seed(0						)
  							__snake_case		       =     sd_pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type="np"      ,return_dict=_lowerCAmelCase      ,)[0]
  
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     image_from_tuple[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 64, 64, 3)
  							__snake_case		       =     np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4]						)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  							assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  					def 							UpperCamelCase_						( self :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     StableDiffusionPipeline.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"      ,safety_checker=_lowerCAmelCase						)
  							assert isinstance(_lowerCAmelCase      ,_lowerCAmelCase						)
  							assert isinstance(pipe.scheduler      ,_lowerCAmelCase						)
  							assert pipe.safety_checker is None
  
  							__snake_case		       =     pipe("example prompt"      ,num_inference_steps=2						).images[0]
  							assert image is not None
  
  							# check that there's no error when saving a pipeline with one of the models being None
  							with tempfile.TemporaryDirectory() as tmpdirname:
  									pipe.save_pretrained(_lowerCAmelCase						)
  									__snake_case		       =     StableDiffusionPipeline.from_pretrained(_lowerCAmelCase						)
  
  							# sanity check that the pipeline still works
  							assert pipe.safety_checker is None
  							__snake_case		       =     pipe("example prompt"      ,num_inference_steps=2						).images[0]
  							assert image is not None
  
  
  
  
  
  
  
  					@unittest.skipIf(torch_device != "cuda"      ,"This test requires a GPU"						)
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.dummy_cond_unet
  							__snake_case		       =     PNDMScheduler(skip_prk_steps=_lowerCAmelCase						)
  							__snake_case		       =     self.dummy_vae
  							__snake_case		       =     self.dummy_text_encoder
  							__snake_case		       =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)
  
  							# put models in fp16
  							__snake_case		       =     unet.half()
  							__snake_case		       =     vae.half()
  							__snake_case		       =     bert.half()
  
  							# make sure here that pndm scheduler skips prk
  							__snake_case		       =     StableDiffusionPipeline(
  							    unet=_lowerCAmelCase      ,scheduler=_lowerCAmelCase      ,vae=_lowerCAmelCase      ,text_encoder=_lowerCAmelCase      ,tokenizer=_lowerCAmelCase      ,safety_checker=_lowerCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
  							__snake_case		       =     sd_pipe.to(_lowerCAmelCase						)
  							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "A painting of a squirrel eating a burger"
  							__snake_case		       =     sd_pipe([prompt]      ,num_inference_steps=2      ,output_type="np"						).images
  
  							assert image.shape == (1, 64, 64, 3)
  
  
  
  
  @nightly
  @require_torch_gpu
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().tearDown()
  							gc.collect()
  							torch.cuda.empty_cache()
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cuda"
  							__snake_case		       =     StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "a photo of a cat"
  							__snake_case		       =     {
  							    "editing_prompt": ["sunglasses"],
  							    "reverse_editing_direction": [False],
  							    "edit_warmup_steps": 10,
  							    "edit_guidance_scale": 6,
  							    "edit_threshold": 0.9_5,
  							    "edit_momentum_scale": 0.5,
  							    "edit_mom_beta": 0.6,
  							}
  
  							__snake_case		       =     3
  							__snake_case		       =     7
  
  							# no sega enabled
  							__snake_case		       =     torch.Generator(_lowerCAmelCase						)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.3_4_6_7_3_1_1_3,
  							    0.3_8_4_9_2_7_3_3,
  							    0.3_7_5_9_7_3_5_2,
  							    0.3_4_0_8_6_3_3_5,
  							    0.3_5_6_5_0_7_4_8,
  							    0.3_5_5_7_9_2_0_5,
  							    0.3_3_8_4_7_6_3,
  							    0.3_4_3_4_0_2_3_6,
  							    0.3_5_7_3_2_7_1,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  							# with sega enabled
  							# generator = torch.manual_seed(seed)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.4_1_8_8_7_8_2_6,
  							    0.3_7_7_2_8_7_6_6,
  							    0.3_0_1_3_8_2_7_2,
  							    0.4_1_4_1_6_3_3_5,
  							    0.4_1_6_6_4_9_8_5,
  							    0.3_6_2_8_3_3_9_2,
  							    0.3_6_1_9_1_2_4_6,
  							    0.4_3_3_6_4_4_6_5,
  							    0.4_3_0_0_1_7_3_2,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cuda"
  							__snake_case		       =     StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "an image of a crowded boulevard, realistic, 4k"
  							__snake_case		       =     {
  							    "editing_prompt": "crowd, crowded, people",
  							    "reverse_editing_direction": True,
  							    "edit_warmup_steps": 10,
  							    "edit_guidance_scale": 8.3,
  							    "edit_threshold": 0.9,
  							    "edit_momentum_scale": 0.5,
  							    "edit_mom_beta": 0.6,
  							}
  
  							__snake_case		       =     9
  							__snake_case		       =     7
  
  							# no sega enabled
  							__snake_case		       =     torch.Generator(_lowerCAmelCase						)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.4_3_4_9_7_9_9_8,
  							    0.9_1_8_1_4_0_6_5,
  							    0.7_5_4_0_7_3_9,
  							    0.5_5_5_8_0_2_0_5,
  							    0.8_4_6_7_2_6_5,
  							    0.5_3_8_9_6_9_1,
  							    0.6_2_5_7_4_5_0_6,
  							    0.5_8_8_9_7_7_6_3,
  							    0.5_0_9_2_6_7_5_7,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  							# with sega enabled
  							# generator = torch.manual_seed(seed)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.3_0_8_9_7_1_9,
  							    0.3_0_5_0_0_1_4_4,
  							    0.2_9_0_1_6_0_4_2,
  							    0.3_0_6_3_0_9_6_4,
  							    0.3_2_5_6_8_7,
  							    0.2_9_4_1_9_2_2_5,
  							    0.2_9_0_8_0_9_1,
  							    0.2_8_7_2_3_5_9_8,
  							    0.2_7_6_9_6_2_9_4,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cuda"
  							__snake_case		       =     StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "a castle next to a river"
  							__snake_case		       =     {
  							    "editing_prompt": ["boat on a river, boat", "monet, impression, sunrise"],
  							    "reverse_editing_direction": False,
  							    "edit_warmup_steps": [15, 18],
  							    "edit_guidance_scale": 6,
  							    "edit_threshold": [0.9, 0.8],
  							    "edit_momentum_scale": 0.5,
  							    "edit_mom_beta": 0.6,
  							}
  
  							__snake_case		       =     48
  							__snake_case		       =     7
  
  							# no sega enabled
  							__snake_case		       =     torch.Generator(_lowerCAmelCase						)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.7_5_1_6_3_5_5_5,
  							    0.7_6_0_3_7_1_4_5,
  							    0.6_1_7_8_5,
  							    0.9_1_8_9_6_7_3,
  							    0.8_6_2_7_7_0_1,
  							    0.8_5_1_8_9_6_9_4,
  							    0.8_5_1_2_8_1_3,
  							    0.8_7_0_1_2_0_7_6,
  							    0.8_3_1_2_8_5_7,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  							# with sega enabled
  							# generator = torch.manual_seed(seed)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.7_3_5_5_3_3_6_5,
  							    0.7_5_3_7_2_7_1,
  							    0.7_4_3_4_1_9_0_5,
  							    0.6_6_4_8_0_3_5_6,
  							    0.6_4_7_2_9_2_5,
  							    0.6_3_0_3_9_4_1_6,
  							    0.6_4_8_1_2_9_0_5,
  							    0.6_7_4_9_7_1_7,
  							    0.6_5_1_7_1_0_2,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cuda"
  							__snake_case		       =     StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"      ,torch_dtype=torch.floataa						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     "a photo of a cat"
  							__snake_case		       =     {
  							    "editing_prompt": ["sunglasses"],
  							    "reverse_editing_direction": [False],
  							    "edit_warmup_steps": 10,
  							    "edit_guidance_scale": 6,
  							    "edit_threshold": 0.9_5,
  							    "edit_momentum_scale": 0.5,
  							    "edit_mom_beta": 0.6,
  							}
  
  							__snake_case		       =     3
  							__snake_case		       =     7
  
  							# no sega enabled
  							__snake_case		       =     torch.Generator(_lowerCAmelCase						)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.3_4_8_8_7_6_9_5,
  							    0.3_8_7_6_9_5_3,
  							    0.3_7_5,
  							    0.3_4_4_2_3_8_2_8,
  							    0.3_5_8_1_5_4_3,
  							    0.3_5_7_1_7_7_7_3,
  							    0.3_3_8_3_7_8_9,
  							    0.3_4_5_7_0_3_1_2,
  							    0.3_5_9_3_7_5,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  							# with sega enabled
  							# generator = torch.manual_seed(seed)
  							generator.manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     pipe(
  							    [prompt]      ,generator=_lowerCAmelCase      ,guidance_scale=_lowerCAmelCase      ,num_inference_steps=50      ,output_type="np"      ,width=512      ,height=512      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     output.images
  							__snake_case		       =     image[0, -3:, -3:, -1]
  							__snake_case		       =     [
  							    0.4_2_2_8_5_1_5_6,
  							    0.3_6_9_1_4_0_6_2,
  							    0.2_9_0_7_7_1_4_8,
  							    0.4_2_0_4_1_0_1_6,
  							    0.4_1_9_1_8_9_4_5,
  							    0.3_5_4_9_8_0_4_7,
  							    0.3_6_1_8_1_6_4,
  							    0.4_4_2_3_8_2_8,
  							    0.4_3_1_1_5_2_3_4,
  							]
  
  							assert image.shape == (1, 512, 512, 3)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  
  
style_context: import gc
  import random
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPImageProcessor, CLIPVisionConfig
  
  from diffusers import AutoencoderKL, PaintByExamplePipeline, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.paint_by_example import PaintByExampleImageEncoder
  from diffusers.utils import floats_tensor, load_image, slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  
  
  class 					UpperCamelCase	(     snake_case__			,      unittest.TestCase      ):
  					__UpperCamelCase						=   PaintByExamplePipeline
  					__UpperCamelCase						=   IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
  					__UpperCamelCase						=   IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  					__UpperCamelCase						=   frozenset([]      )  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							torch.manual_seed(0						)
  							__snake_case		       =     UNetaDConditionModel(
  							    block_out_channels=(32, 64)      ,layers_per_block=2      ,sample_size=32      ,in_channels=9      ,out_channels=4      ,down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")      ,up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")      ,cross_attention_dim=32      ,)
  							__snake_case		       =     PNDMScheduler(skip_prk_steps=_lowerCAmelCase						)
  							torch.manual_seed(0						)
  							__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						)
  							__snake_case		       =     CLIPVisionConfig(
  							    hidden_size=32      ,projection_dim=32      ,intermediate_size=37      ,layer_norm_eps=1E-05      ,num_attention_heads=4      ,num_hidden_layers=5      ,image_size=32      ,patch_size=4      ,)
  							__snake_case		       =     PaintByExampleImageEncoder(_lowerCAmelCase      ,proj_size=32						)
  							__snake_case		       =     CLIPImageProcessor(crop_size=32      ,size=32						)
  
  							__snake_case		       =     {
  							    "unet": unet,
  							    "scheduler": scheduler,
  							    "vae": vae,
  							    "image_encoder": image_encoder,
  							    "safety_checker": None,
  							    "feature_extractor": feature_extractor,
  							}
  							return components
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     np.array(image.convert("RGB"						)						)
  							__snake_case		       =     image[None].transpose(0      ,3      ,1      ,2						)
  							__snake_case		       =     torch.from_numpy(_lowerCAmelCase						).to(dtype=torch.floataa						) / 1_2_7.5 - 1.0
  							return image
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any="cpu"      ,_lowerCAmelCase :					List[str]=0						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     floats_tensor((1, 3, 32, 32)      ,rng=random.Random(_lowerCAmelCase						)						).to(_lowerCAmelCase						)
  							__snake_case		       =     image.cpu().permute(0      ,2      ,3      ,1						)[0]
  							__snake_case		       =     Image.fromarray(np.uinta(_lowerCAmelCase						)						).convert("RGB"						).resize((64, 64)						)
  							__snake_case		       =     Image.fromarray(np.uinta(image + 4						)						).convert("RGB"						).resize((64, 64)						)
  							__snake_case		       =     Image.fromarray(np.uinta(_lowerCAmelCase						)						).convert("RGB"						).resize((32, 32)						)
  
  							if str(_lowerCAmelCase						).startswith("mps"						):
  									__snake_case		       =     torch.manual_seed(_lowerCAmelCase						)
  							else:
  									__snake_case		       =     torch.Generator(device=_lowerCAmelCase						).manual_seed(_lowerCAmelCase						)
  							__snake_case		       =     {
  							    "example_image": example_image,
  							    "image": init_image,
  							    "mask_image": mask_image,
  							    "generator": generator,
  							    "num_inference_steps": 2,
  							    "guidance_scale": 6.0,
  							    "output_type": "numpy",
  							}
  							return inputs
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.get_dummy_components()
  
  							# make sure here that pndm scheduler skips prk
  							__snake_case		       =     PaintByExamplePipeline(**_lowerCAmelCase						)
  							__snake_case		       =     pipe.to("cpu"						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     self.get_dummy_inputs()
  							__snake_case		       =     pipe(**_lowerCAmelCase						)
  							__snake_case		       =     output.images
  
  							__snake_case		       =     image[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 64, 64, 3)
  							__snake_case		       =     np.array([0.4_6_8_6, 0.5_6_8_7, 0.4_0_0_7, 0.5_2_1_8, 0.5_7_4_1, 0.4_4_8_2, 0.4_9_4_0, 0.4_6_2_9, 0.4_5_0_3]						)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     "cpu"
  							__snake_case		       =     self.get_dummy_inputs()
  							inputs.pop("mask_image"						)
  							__snake_case		       =     self.convert_to_pt(inputs.pop("image"						)						)
  							__snake_case		       =     image.clamp(0      ,1						) / 2
  
  							# make sure here that pndm scheduler skips prk
  							__snake_case		       =     PaintByExamplePipeline(**self.get_dummy_components()						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     pipe(image=_lowerCAmelCase      ,mask_image=mask_image[:, 0]      ,**_lowerCAmelCase						)
  							__snake_case		       =     output.images
  
  							__snake_case		       =     image.cpu().permute(0      ,2      ,3      ,1						)[0]
  							__snake_case		       =     mask_image.cpu().permute(0      ,2      ,3      ,1						)[0]
  
  							__snake_case		       =     Image.fromarray(np.uinta(_lowerCAmelCase						)						).convert("RGB"						)
  							__snake_case		       =     Image.fromarray(np.uinta(_lowerCAmelCase						)						).convert("RGB"						)
  
  							__snake_case		       =     pipe(**self.get_dummy_inputs()						)
  							__snake_case		       =     output.images
  
  							assert out_a.shape == (1, 64, 64, 3)
  							assert np.abs(out_a.flatten() - out_a.flatten()						).max() < 5E-2
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().test_inference_batch_single_identical(expected_max_diff=3E-3						)
  
  
  
  
  @slow
  @require_torch_gpu
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().tearDown()
  							gc.collect()
  							torch.cuda.empty_cache()
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     load_image(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
  							    "/paint_by_example/dog_in_bucket.png"						)
  							__snake_case		       =     load_image(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
  							    "/paint_by_example/mask.png"						)
  							__snake_case		       =     load_image(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
  							    "/paint_by_example/panda.jpg"						)
  
  							__snake_case		       =     PaintByExamplePipeline.from_pretrained("Fantasy-Studio/Paint-by-Example"						)
  							__snake_case		       =     pipe.to(_lowerCAmelCase						)
  							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
  
  							__snake_case		       =     torch.manual_seed(321						)
  							__snake_case		       =     pipe(
  							    image=_lowerCAmelCase      ,mask_image=_lowerCAmelCase      ,example_image=_lowerCAmelCase      ,generator=_lowerCAmelCase      ,guidance_scale=5.0      ,num_inference_steps=50      ,output_type="np"      ,)
  
  							__snake_case		       =     output.images
  
  							__snake_case		       =     image[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 512, 512, 3)
  							__snake_case		       =     np.array([0.4_8_3_4, 0.4_8_1_1, 0.4_8_7_4, 0.5_1_2_2, 0.5_0_8_1, 0.5_1_4_4, 0.5_2_9_1, 0.5_2_9_0, 0.5_3_7_4]						)
  
  							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
  
  
  
  
  
  