code: 
  
  
  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   lowerCAmelCase__ (       a  ,					unittest.TestCase):
  
  
  
  
       '''simple docstring'''
       __SCREAMING_SNAKE_CASE						    =				PaintByExamplePipeline
       __SCREAMING_SNAKE_CASE						    =				IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
       __SCREAMING_SNAKE_CASE						    =				IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
       __SCREAMING_SNAKE_CASE						    =				frozenset([])  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
       def 				_lowerCamelCase				(		self)    ->       Dict:
              torch.manual_seed(0)
              _A   : str       					=				UNetaDConditionModel(
                  block_out_channels=(3_2, 6_4)				,		layers_per_block=2				,		sample_size=3_2				,		in_channels=9				,		out_channels=4				,		down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")				,		up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")				,		cross_attention_dim=3_2				,		)
              _A   : Optional[Any]       					=				PNDMScheduler(skip_prk_steps=__lowerCamelCase)
              torch.manual_seed(0)
              _A   : Any       					=				AutoencoderKL(
                  block_out_channels=[3_2, 6_4]				,		in_channels=3				,		out_channels=3				,		down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]				,		up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]				,		latent_channels=4				,		)
              torch.manual_seed(0)
              _A   : str       					=				CLIPVisionConfig(
                  hidden_size=3_2				,		projection_dim=3_2				,		intermediate_size=3_7				,		layer_norm_eps=1e-05				,		num_attention_heads=4				,		num_hidden_layers=5				,		image_size=3_2				,		patch_size=4				,		)
              _A   : Union[str, Any]       					=				PaintByExampleImageEncoder(__lowerCamelCase				,		proj_size=3_2)
              _A   : int       					=				CLIPImageProcessor(crop_size=3_2				,		size=3_2)
  
              _A   : Optional[int]       					=				{
                  "unet": unet,
                  "scheduler": scheduler,
                  "vae": vae,
                  "image_encoder": image_encoder,
                  "safety_checker": None,
                  "feature_extractor": feature_extractor,
              }
              return components
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase)    ->       Optional[Any]:
              _A   : Dict       					=				np.array(image.convert("RGB"))
              _A   : Any       					=				image[None].transpose(0				,		3				,		1				,		2)
              _A   : Any       					=				torch.from_numpy(__lowerCamelCase).to(dtype=torch.floataa) / 1_2_7.5 - 1.0
              return image
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase="cpu"				,		__lowerCamelCase=0)    ->       List[Any]:
              # TODO: use tensor inputs instead of PIL, this is here just to leave the old expected_slices untouched
              _A   : Optional[Any]       					=				floats_tensor((1, 3, 3_2, 3_2)				,		rng=random.Random(__lowerCamelCase)).to(__lowerCamelCase)
              _A   : List[str]       					=				image.cpu().permute(0				,		2				,		3				,		1)[0]
              _A   : Union[str, Any]       					=				Image.fromarray(np.uinta(__lowerCamelCase)).convert("RGB").resize((6_4, 6_4))
              _A   : List[Any]       					=				Image.fromarray(np.uinta(image + 4)).convert("RGB").resize((6_4, 6_4))
              _A   : Dict       					=				Image.fromarray(np.uinta(__lowerCamelCase)).convert("RGB").resize((3_2, 3_2))
  
              if str(__lowerCamelCase).startswith("mps"):
                     _A   : Dict       					=				torch.manual_seed(__lowerCamelCase)
              else:
                     _A   : Union[str, Any]       					=				torch.Generator(device=__lowerCamelCase).manual_seed(__lowerCamelCase)
              _A   : Dict       					=				{
                  "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 				_lowerCamelCase				(		self)    ->       List[Any]:
              _A   : Union[str, Any]       					=				self.get_dummy_components()
  
              # make sure here that pndm scheduler skips prk
              _A   : List[Any]       					=				PaintByExamplePipeline(**__lowerCamelCase)
              _A   : Optional[Any]       					=				pipe.to("cpu")
              pipe.set_progress_bar_config(disable=__lowerCamelCase)
  
              _A   : Any       					=				self.get_dummy_inputs()
              _A   : Dict       					=				pipe(**__lowerCamelCase)
              _A   : str       					=				output.images
  
              _A   : int       					=				image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 6_4, 6_4, 3)
              _A   : Tuple       					=				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 				_lowerCamelCase				(		self)    ->       str:
              _A   : str       					=				"cpu"
              _A   : Union[str, Any]       					=				self.get_dummy_inputs()
              inputs.pop("mask_image")
              _A   : Dict       					=				self.convert_to_pt(inputs.pop("image"))
              _A   : Optional[int]       					=				image.clamp(0				,		1) / 2
  
              # make sure here that pndm scheduler skips prk
              _A   : Tuple       					=				PaintByExamplePipeline(**self.get_dummy_components())
              _A   : Union[str, Any]       					=				pipe.to(__lowerCamelCase)
              pipe.set_progress_bar_config(disable=__lowerCamelCase)
  
              _A   : Union[str, Any]       					=				pipe(image=__lowerCamelCase				,		mask_image=mask_image[:, 0]				,		**__lowerCamelCase)
              _A   : Optional[Any]       					=				output.images
  
              _A   : Optional[Any]       					=				image.cpu().permute(0				,		2				,		3				,		1)[0]
              _A   : str       					=				mask_image.cpu().permute(0				,		2				,		3				,		1)[0]
  
              _A   : Optional[Any]       					=				Image.fromarray(np.uinta(__lowerCamelCase)).convert("RGB")
              _A   : int       					=				Image.fromarray(np.uinta(__lowerCamelCase)).convert("RGB")
  
              _A   : int       					=				pipe(**self.get_dummy_inputs())
              _A   : List[str]       					=				output.images
  
              assert out_a.shape == (1, 6_4, 6_4, 3)
              assert np.abs(out_a.flatten() - out_a.flatten()).max() < 5e-2
  
  
       def 				_lowerCamelCase				(		self)    ->       Union[str, Any]:
              super().test_inference_batch_single_identical(expected_max_diff=3e-3)
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class   lowerCAmelCase__ (       unittest.TestCase):
  
  
  
  
       '''simple docstring'''
  
  
       def 				_lowerCamelCase				(		self)    ->       List[str]:
              # clean up the VRAM after each test
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
       def 				_lowerCamelCase				(		self)    ->       str:
              # make sure here that pndm scheduler skips prk
              _A   : Union[str, Any]       					=				load_image(
                  "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                  "/paint_by_example/dog_in_bucket.png")
              _A   : List[Any]       					=				load_image(
                  "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                  "/paint_by_example/mask.png")
              _A   : Tuple       					=				load_image(
                  "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                  "/paint_by_example/panda.jpg")
  
              _A   : Optional[int]       					=				PaintByExamplePipeline.from_pretrained("Fantasy-Studio/Paint-by-Example")
              _A   : List[Any]       					=				pipe.to(__lowerCamelCase)
              pipe.set_progress_bar_config(disable=__lowerCamelCase)
  
              _A   : Union[str, Any]       					=				torch.manual_seed(3_2_1)
              _A   : Optional[int]       					=				pipe(
                  image=__lowerCamelCase				,		mask_image=__lowerCamelCase				,		example_image=__lowerCamelCase				,		generator=__lowerCamelCase				,		guidance_scale=5.0				,		num_inference_steps=5_0				,		output_type="np"				,		)
  
              _A   : Optional[Any]       					=				output.images
  
              _A   : Optional[int]       					=				image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 5_1_2, 5_1_2, 3)
              _A   : int       					=				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
  
style_context: 
  
  
  lowerCAmelCase__   	=				'\n# Transformers installation\n! pip install transformers datasets evaluate\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'
  
  lowerCAmelCase__   	=				[{'type': 'code', 'content': INSTALL_CONTENT}]
  lowerCAmelCase__   	=				{
      '{processor_class}': 'FakeProcessorClass',
      '{model_class}': 'FakeModelClass',
      '{object_class}': 'FakeObjectClass',
  }
  