code: # This model implementation is heavily based on:
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      ControlNetModel,
      DDIMScheduler,
      StableDiffusionControlNetInpaintPipeline,
      UNetaDConditionModel,
  )
  from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
  from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import (
      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
      TEXT_TO_IMAGE_IMAGE_PARAMS,
  )
  from ..test_pipelines_common import (
      PipelineKarrasSchedulerTesterMixin,
      PipelineLatentTesterMixin,
      PipelineTesterMixin,
  )
  
  
  enable_full_determinism()
  
  
  
  
  class      lowercase_						(						UpperCamelCase_   ,  UpperCamelCase_   ,  UpperCamelCase_   ,  unittest.TestCase				):
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	UpperCAmelCase_						:      List[Any]     =       StableDiffusionControlNetInpaintPipeline
  	UpperCAmelCase_						:      List[str]     =       TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	UpperCAmelCase_						:      Tuple     =       TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  	UpperCAmelCase_						:      List[str]     =       frozenset({"""control_image"""}				)  # skip `image` and `mask` for now, only test for control_image
  	UpperCAmelCase_						:      List[str]     =       TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[Any]:
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	ControlNetModel(
  								    block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	DDIMScheduler(
  								    beta_start=0.0_0_0_8_5	,    beta_end=0.0_1_2	,    beta_schedule='''scaled_linear'''	,    clip_sample=__SCREAMING_SNAKE_CASE	,    set_alpha_to_one=__SCREAMING_SNAKE_CASE	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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       )
  								lowerCAmelCase				=	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	,    )
  								lowerCAmelCase				=	CLIPTextModel(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
  
  								lowerCAmelCase				=	{
  								    '''unet''': unet,
  								    '''controlnet''': controlnet,
  								    '''scheduler''': scheduler,
  								    '''vae''': vae,
  								    '''text_encoder''': text_encoder,
  								    '''tokenizer''': tokenizer,
  								    '''safety_checker''': None,
  								    '''feature_extractor''': None,
  								}
  								return components
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self	,    __SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE=0       )		->Dict:
  								if str(__SCREAMING_SNAKE_CASE       ).startswith('''mps'''       ):
  															lowerCAmelCase				=	torch.manual_seed(__SCREAMING_SNAKE_CASE       )
  								else:
  															lowerCAmelCase				=	torch.Generator(device=__SCREAMING_SNAKE_CASE       ).manual_seed(__SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	2
  								lowerCAmelCase				=	randn_tensor(
  								    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=__SCREAMING_SNAKE_CASE	,    device=torch.device(__SCREAMING_SNAKE_CASE       )	,    )
  								lowerCAmelCase				=	floats_tensor((1, 3, 32, 32)	,    rng=random.Random(__SCREAMING_SNAKE_CASE       )       ).to(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	init_image.cpu().permute(0	,    2	,    3	,    1       )[0]
  
  								lowerCAmelCase				=	Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE       )       ).convert('''RGB'''       ).resize((64, 64)       )
  								lowerCAmelCase				=	Image.fromarray(np.uinta(init_image + 4       )       ).convert('''RGB'''       ).resize((64, 64)       )
  
  								lowerCAmelCase				=	{
  								    '''prompt''': '''A painting of a squirrel eating a burger''',
  								    '''generator''': generator,
  								    '''num_inference_steps''': 2,
  								    '''guidance_scale''': 6.0,
  								    '''output_type''': '''numpy''',
  								    '''image''': image,
  								    '''mask_image''': mask_image,
  								    '''control_image''': control_image,
  								}
  
  								return inputs
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->int:
  								return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3       )
  
  
  	@unittest.skipIf(
  	    torch_device != '''cuda''' or not is_xformers_available()	,    reason='''XFormers attention is only available with CUDA and `xformers` installed'''	,    )
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Dict:
  								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )
  
  
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[int]:
  								self._test_inference_batch_single_identical(expected_max_diff=2e-3       )
  
  
  
  
  class      lowercase_						(						UpperCamelCase_				):
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	UpperCAmelCase_						:      Dict     =       StableDiffusionControlNetInpaintPipeline
  	UpperCAmelCase_						:      Dict     =       TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	UpperCAmelCase_						:      Any     =       TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  	UpperCAmelCase_						:      int     =       frozenset([]				)
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Dict:
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	ControlNetModel(
  								    block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	DDIMScheduler(
  								    beta_start=0.0_0_0_8_5	,    beta_end=0.0_1_2	,    beta_schedule='''scaled_linear'''	,    clip_sample=__SCREAMING_SNAKE_CASE	,    set_alpha_to_one=__SCREAMING_SNAKE_CASE	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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       )
  								lowerCAmelCase				=	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	,    )
  								lowerCAmelCase				=	CLIPTextModel(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
  
  								lowerCAmelCase				=	{
  								    '''unet''': unet,
  								    '''controlnet''': controlnet,
  								    '''scheduler''': scheduler,
  								    '''vae''': vae,
  								    '''text_encoder''': text_encoder,
  								    '''tokenizer''': tokenizer,
  								    '''safety_checker''': None,
  								    '''feature_extractor''': None,
  								}
  								return components
  
  
  
  
  class      lowercase_						(						UpperCamelCase_   ,  UpperCamelCase_   ,  unittest.TestCase				):
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	UpperCAmelCase_						:      Optional[int]     =       StableDiffusionControlNetInpaintPipeline
  	UpperCAmelCase_						:      Optional[int]     =       TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	UpperCAmelCase_						:      Any     =       TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[Any]:
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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	,    )
  								torch.manual_seed(0       )
  
  								def init_weights(__SCREAMING_SNAKE_CASE       ):
  															if isinstance(__SCREAMING_SNAKE_CASE	,    torch.nn.Convad       ):
  																						torch.nn.init.normal(m.weight       )
  																						m.bias.data.fill_(1.0       )
  
  								lowerCAmelCase				=	ControlNetModel(
  								    block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
  								controlneta.controlnet_down_blocks.apply(__SCREAMING_SNAKE_CASE       )
  
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	ControlNetModel(
  								    block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
  								controlneta.controlnet_down_blocks.apply(__SCREAMING_SNAKE_CASE       )
  
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	DDIMScheduler(
  								    beta_start=0.0_0_0_8_5	,    beta_end=0.0_1_2	,    beta_schedule='''scaled_linear'''	,    clip_sample=__SCREAMING_SNAKE_CASE	,    set_alpha_to_one=__SCREAMING_SNAKE_CASE	,    )
  								torch.manual_seed(0       )
  								lowerCAmelCase				=	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       )
  								lowerCAmelCase				=	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	,    )
  								lowerCAmelCase				=	CLIPTextModel(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
  
  								lowerCAmelCase				=	MultiControlNetModel([controlneta, controlneta]       )
  
  								lowerCAmelCase				=	{
  								    '''unet''': unet,
  								    '''controlnet''': controlnet,
  								    '''scheduler''': scheduler,
  								    '''vae''': vae,
  								    '''text_encoder''': text_encoder,
  								    '''tokenizer''': tokenizer,
  								    '''safety_checker''': None,
  								    '''feature_extractor''': None,
  								}
  								return components
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self	,    __SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE=0       )		->List[Any]:
  								if str(__SCREAMING_SNAKE_CASE       ).startswith('''mps'''       ):
  															lowerCAmelCase				=	torch.manual_seed(__SCREAMING_SNAKE_CASE       )
  								else:
  															lowerCAmelCase				=	torch.Generator(device=__SCREAMING_SNAKE_CASE       ).manual_seed(__SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	2
  
  								lowerCAmelCase				=	[
  								    randn_tensor(
  								        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=__SCREAMING_SNAKE_CASE	,    device=torch.device(__SCREAMING_SNAKE_CASE       )	,    ),
  								    randn_tensor(
  								        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=__SCREAMING_SNAKE_CASE	,    device=torch.device(__SCREAMING_SNAKE_CASE       )	,    ),
  								]
  								lowerCAmelCase				=	floats_tensor((1, 3, 32, 32)	,    rng=random.Random(__SCREAMING_SNAKE_CASE       )       ).to(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	init_image.cpu().permute(0	,    2	,    3	,    1       )[0]
  
  								lowerCAmelCase				=	Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE       )       ).convert('''RGB'''       ).resize((64, 64)       )
  								lowerCAmelCase				=	Image.fromarray(np.uinta(init_image + 4       )       ).convert('''RGB'''       ).resize((64, 64)       )
  
  								lowerCAmelCase				=	{
  								    '''prompt''': '''A painting of a squirrel eating a burger''',
  								    '''generator''': generator,
  								    '''num_inference_steps''': 2,
  								    '''guidance_scale''': 6.0,
  								    '''output_type''': '''numpy''',
  								    '''image''': image,
  								    '''mask_image''': mask_image,
  								    '''control_image''': control_image,
  								}
  
  								return inputs
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Dict:
  								lowerCAmelCase				=	self.get_dummy_components()
  								lowerCAmelCase				=	self.pipeline_class(**__SCREAMING_SNAKE_CASE       )
  								pipe.to(__SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	10.0
  								lowerCAmelCase				=	4
  
  								lowerCAmelCase				=	self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	steps
  								lowerCAmelCase				=	scale
  								lowerCAmelCase				=	pipe(**__SCREAMING_SNAKE_CASE       )[0]
  
  								lowerCAmelCase				=	self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	steps
  								lowerCAmelCase				=	scale
  								lowerCAmelCase				=	pipe(**__SCREAMING_SNAKE_CASE	,    control_guidance_start=0.1	,    control_guidance_end=0.2       )[0]
  
  								lowerCAmelCase				=	self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	steps
  								lowerCAmelCase				=	scale
  								lowerCAmelCase				=	pipe(**__SCREAMING_SNAKE_CASE	,    control_guidance_start=[0.1, 0.3]	,    control_guidance_end=[0.2, 0.7]       )[0]
  
  								lowerCAmelCase				=	self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	steps
  								lowerCAmelCase				=	scale
  								lowerCAmelCase				=	pipe(**__SCREAMING_SNAKE_CASE	,    control_guidance_start=0.4	,    control_guidance_end=[0.5, 0.8]       )[0]
  
  								# make sure that all outputs are different
  								assert np.sum(np.abs(output_a - output_a       )       ) > 1e-3
  								assert np.sum(np.abs(output_a - output_a       )       ) > 1e-3
  								assert np.sum(np.abs(output_a - output_a       )       ) > 1e-3
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->str:
  								return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3       )
  
  
  	@unittest.skipIf(
  	    torch_device != '''cuda''' or not is_xformers_available()	,    reason='''XFormers attention is only available with CUDA and `xformers` installed'''	,    )
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Any:
  								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Any:
  								self._test_inference_batch_single_identical(expected_max_diff=2e-3       )
  
  
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Union[str, Any]:
  								lowerCAmelCase				=	self.get_dummy_components()
  								lowerCAmelCase				=	self.pipeline_class(**__SCREAMING_SNAKE_CASE       )
  								pipe.to(__SCREAMING_SNAKE_CASE       )
  								pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )
  								with tempfile.TemporaryDirectory() as tmpdir:
  															try:
  																						# save_pretrained is not implemented for Multi-ControlNet
  																						pipe.save_pretrained(__SCREAMING_SNAKE_CASE       )
  															except NotImplementedError:
  																						pass
  
  
  
  
  @slow
  @require_torch_gpu
  class      lowercase_						(						unittest.TestCase				):
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Optional[int]:
  								super().tearDown()
  								gc.collect()
  								torch.cuda.empty_cache()
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->List[Any]:
  								lowerCAmelCase				=	ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''       )
  
  								lowerCAmelCase				=	StableDiffusionControlNetInpaintPipeline.from_pretrained(
  								    '''runwayml/stable-diffusion-inpainting'''	,    safety_checker=__SCREAMING_SNAKE_CASE	,    controlnet=__SCREAMING_SNAKE_CASE       )
  								pipe.enable_model_cpu_offload()
  								pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	torch.Generator(device='''cpu'''       ).manual_seed(0       )
  								lowerCAmelCase				=	load_image(
  								    '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''       ).resize((512, 512)       )
  
  								lowerCAmelCase				=	load_image(
  								    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
  								    '''/stable_diffusion_inpaint/input_bench_mask.png'''       ).resize((512, 512)       )
  
  								lowerCAmelCase				=	'''pitch black hole'''
  
  								lowerCAmelCase				=	load_image(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''       ).resize((512, 512)       )
  
  								lowerCAmelCase				=	pipe(
  								    __SCREAMING_SNAKE_CASE	,    image=__SCREAMING_SNAKE_CASE	,    mask_image=__SCREAMING_SNAKE_CASE	,    control_image=__SCREAMING_SNAKE_CASE	,    generator=__SCREAMING_SNAKE_CASE	,    output_type='''np'''	,    num_inference_steps=3	,    )
  
  								lowerCAmelCase				=	output.images[0]
  
  								assert image.shape == (512, 512, 3)
  
  								lowerCAmelCase				=	load_numpy(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy'''       )
  
  								assert np.abs(expected_image - image       ).max() < 9e-2
  
  
  
  
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->Dict:
  								lowerCAmelCase				=	ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''       )
  
  								lowerCAmelCase				=	StableDiffusionControlNetInpaintPipeline.from_pretrained(
  								    '''runwayml/stable-diffusion-v1-5'''	,    safety_checker=__SCREAMING_SNAKE_CASE	,    controlnet=__SCREAMING_SNAKE_CASE       )
  								lowerCAmelCase				=	DDIMScheduler.from_config(pipe.scheduler.config       )
  								pipe.enable_model_cpu_offload()
  								pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	torch.Generator(device='''cpu'''       ).manual_seed(33       )
  
  								lowerCAmelCase				=	load_image(
  								    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'''       )
  								lowerCAmelCase				=	init_image.resize((512, 512)       )
  
  								lowerCAmelCase				=	load_image(
  								    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'''       )
  								lowerCAmelCase				=	mask_image.resize((512, 512)       )
  
  								lowerCAmelCase				=	'''a handsome man with ray-ban sunglasses'''
  
  								def make_inpaint_condition(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
  															lowerCAmelCase				=	np.array(image.convert('''RGB'''       )       ).astype(np.floataa       ) / 255.0
  															lowerCAmelCase				=	np.array(image_mask.convert('''L'''       )       ).astype(np.floataa       ) / 255.0
  
  															assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
  															lowerCAmelCase				=	-1.0  # set as masked pixel
  															lowerCAmelCase				=	np.expand_dims(__SCREAMING_SNAKE_CASE	,    0       ).transpose(0	,    3	,    1	,    2       )
  															lowerCAmelCase				=	torch.from_numpy(__SCREAMING_SNAKE_CASE       )
  															return image
  
  								lowerCAmelCase				=	make_inpaint_condition(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       )
  
  								lowerCAmelCase				=	pipe(
  								    __SCREAMING_SNAKE_CASE	,    image=__SCREAMING_SNAKE_CASE	,    mask_image=__SCREAMING_SNAKE_CASE	,    control_image=__SCREAMING_SNAKE_CASE	,    guidance_scale=9.0	,    eta=1.0	,    generator=__SCREAMING_SNAKE_CASE	,    num_inference_steps=20	,    output_type='''np'''	,    )
  								lowerCAmelCase				=	output.images[0]
  
  								assert image.shape == (512, 512, 3)
  
  								lowerCAmelCase				=	load_numpy(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy'''       )
  
  								assert np.abs(expected_image - image       ).max() < 9e-2
  
  
  
  
style_context: from typing import Callable, Optional, Union
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  lowercase__    :       Optional[Any]						=			logging.get_logger(__name__)
  
  lowercase__    :       Union[str, Any]						=			{
      '''microsoft/prophetnet-large-uncased''': (
          '''https://huggingface.co/microsoft/prophetnet-large-uncased/resolve/main/config.json'''
      ),
  }
  
  
  
  
  class      lowercase_						(						UpperCamelCase_		):
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  	UpperCAmelCase_						:      Optional[int]     =       """prophetnet"""
  	UpperCAmelCase_						:      Optional[int]     =       ["""past_key_values"""]
  	UpperCAmelCase_						:      Any     =       {
  	    """num_attention_heads""": """num_encoder_attention_heads""",
  	}
  
  
  	def __init__(							self	,    __SCREAMING_SNAKE_CASE = 0.1	,    __SCREAMING_SNAKE_CASE = "gelu"	,    __SCREAMING_SNAKE_CASE = 30522	,    __SCREAMING_SNAKE_CASE = 1024	,    __SCREAMING_SNAKE_CASE = 4096	,    __SCREAMING_SNAKE_CASE = 12	,    __SCREAMING_SNAKE_CASE = 16	,    __SCREAMING_SNAKE_CASE = 4096	,    __SCREAMING_SNAKE_CASE = 12	,    __SCREAMING_SNAKE_CASE = 16	,    __SCREAMING_SNAKE_CASE = 0.1	,    __SCREAMING_SNAKE_CASE = 0.1	,    __SCREAMING_SNAKE_CASE = 512	,    __SCREAMING_SNAKE_CASE = 0.0_2	,    __SCREAMING_SNAKE_CASE = True	,    __SCREAMING_SNAKE_CASE = True	,    __SCREAMING_SNAKE_CASE = 0	,    __SCREAMING_SNAKE_CASE = 2	,    __SCREAMING_SNAKE_CASE = 32	,    __SCREAMING_SNAKE_CASE = 128	,    __SCREAMING_SNAKE_CASE = False	,    __SCREAMING_SNAKE_CASE = 0.0	,    __SCREAMING_SNAKE_CASE = True	,    __SCREAMING_SNAKE_CASE = 0	,    __SCREAMING_SNAKE_CASE = 1	,    __SCREAMING_SNAKE_CASE = 2	,    **__SCREAMING_SNAKE_CASE	,    )		->int:
  								lowerCAmelCase				=	vocab_size
  								lowerCAmelCase				=	hidden_size
  								lowerCAmelCase				=	encoder_ffn_dim
  								lowerCAmelCase				=	num_encoder_layers
  								lowerCAmelCase				=	num_encoder_attention_heads
  								lowerCAmelCase				=	decoder_ffn_dim
  								lowerCAmelCase				=	num_decoder_layers
  								lowerCAmelCase				=	num_decoder_attention_heads
  								lowerCAmelCase				=	max_position_embeddings
  								lowerCAmelCase				=	init_std  # Normal(0, this parameter)
  								lowerCAmelCase				=	activation_function
  
  								# parameters for prophetnet
  								lowerCAmelCase				=	ngram
  								lowerCAmelCase				=	num_buckets
  								lowerCAmelCase				=	relative_max_distance
  								lowerCAmelCase				=	disable_ngram_loss
  								lowerCAmelCase				=	eps
  
  								# 3 Types of Dropout
  								lowerCAmelCase				=	attention_dropout
  								lowerCAmelCase				=	activation_dropout
  								lowerCAmelCase				=	dropout
  
  								lowerCAmelCase				=	use_cache
  
  								super().__init__(
  								    pad_token_id=__SCREAMING_SNAKE_CASE	,    bos_token_id=__SCREAMING_SNAKE_CASE	,    eos_token_id=__SCREAMING_SNAKE_CASE	,    is_encoder_decoder=__SCREAMING_SNAKE_CASE	,    add_cross_attention=__SCREAMING_SNAKE_CASE	,    decoder_start_token_id=__SCREAMING_SNAKE_CASE	,    **__SCREAMING_SNAKE_CASE	,    )
  
  
  	@property
  	def     SCREAMING_SNAKE_CASE_       (							self       )		->int:
  								return self.num_encoder_layers + self.num_decoder_layers
  
  
  
  
  	@num_hidden_layers.setter
  	def     SCREAMING_SNAKE_CASE_       (							self	,    __SCREAMING_SNAKE_CASE       )		->Union[str, Any]:
  								raise NotImplementedError(
  								    '''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
  								    ''' `num_decoder_layers`.'''       )
  
  
  
  