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 			a      (      UpperCamelCase_      ,unittest.TestCase   ):
  		__lowercase													=		PaintByExamplePipeline
  		__lowercase													=		IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
  		__lowercase													=		IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  		__lowercase													=		frozenset([]   )  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						torch.manual_seed(0							)
  						A__     :							Optional[int]   				=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	,     )
  						A__     :							Any   				=PNDMScheduler(skip_prk_steps=__UpperCamelCase							)
  						torch.manual_seed(0							)
  						A__     :							int   				=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							)
  						A__     :							Tuple   				=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	,     )
  						A__     :							int   				=PaintByExampleImageEncoder(__UpperCamelCase	,     proj_size=32							)
  						A__     :							int   				=CLIPImageProcessor(crop_size=32	,     size=32							)
  
  						A__     :							List[str]   				={
  						    '''unet''': unet,
  						    '''scheduler''': scheduler,
  						    '''vae''': vae,
  						    '''image_encoder''': image_encoder,
  						    '''safety_checker''': None,
  						    '''feature_extractor''': feature_extractor,
  						}
  						return components
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase							)->			Dict:
  						'''simple docstring'''
  
  
  						A__     :							Tuple   				=np.array(image.convert('''RGB'''							)							)
  						A__     :							List[Any]   				=image[None].transpose(0	,     3	,     1	,     2							)
  						A__     :							List[Any]   				=torch.from_numpy(__UpperCamelCase							).to(dtype=torch.floataa							) / 127.5 - 1.0
  						return image
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase="cpu"	,     __UpperCamelCase=0							)->			Any:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				=floats_tensor((1, 3, 32, 32)	,     rng=random.Random(__UpperCamelCase							)							).to(__UpperCamelCase							)
  						A__     :							List[str]   				=image.cpu().permute(0	,     2	,     3	,     1							)[0]
  						A__     :							str   				=Image.fromarray(np.uinta(__UpperCamelCase							)							).convert('''RGB'''							).resize((64, 64)							)
  						A__     :							Union[str, Any]   				=Image.fromarray(np.uinta(image + 4							)							).convert('''RGB'''							).resize((64, 64)							)
  						A__     :							Tuple   				=Image.fromarray(np.uinta(__UpperCamelCase							)							).convert('''RGB'''							).resize((32, 32)							)
  
  						if str(__UpperCamelCase							).startswith('''mps'''							):
  										A__     :							Optional[Any]   				=torch.manual_seed(__UpperCamelCase							)
  						else:
  										A__     :							Optional[int]   				=torch.Generator(device=__UpperCamelCase							).manual_seed(__UpperCamelCase							)
  						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							)->			Dict:
  						'''simple docstring'''
  
  
  						A__     :							List[Any]   				=self.get_dummy_components()
  
  						# make sure here that pndm scheduler skips prk
  						A__     :							List[Any]   				=PaintByExamplePipeline(**__UpperCamelCase							)
  						A__     :							Dict   				=pipe.to('''cpu'''							)
  						pipe.set_progress_bar_config(disable=__UpperCamelCase							)
  
  						A__     :							Optional[int]   				=self.get_dummy_inputs()
  						A__     :							Optional[int]   				=pipe(**__UpperCamelCase							)
  						A__     :							Dict   				=output.images
  
  						A__     :							List[Any]   				=image[0, -3:, -3:, -1]
  
  						assert image.shape == (1, 64, 64, 3)
  						A__     :							int   				=np.array([0.4686, 0.5687, 0.4007, 0.5218, 0.5741, 0.4482, 0.4940, 0.4629, 0.4503]							)
  
  						assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			List[str]:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				='''cpu'''
  						A__     :							Any   				=self.get_dummy_inputs()
  						inputs.pop('''mask_image'''							)
  						A__     :							Dict   				=self.convert_to_pt(inputs.pop('''image'''							)							)
  						A__     :							str   				=image.clamp(0	,     1							) / 2
  
  						# make sure here that pndm scheduler skips prk
  						A__     :							Any   				=PaintByExamplePipeline(**self.get_dummy_components()							)
  						A__     :							Any   				=pipe.to(__UpperCamelCase							)
  						pipe.set_progress_bar_config(disable=__UpperCamelCase							)
  
  						A__     :							Union[str, Any]   				=pipe(image=__UpperCamelCase	,     mask_image=mask_image[:, 0]	,     **__UpperCamelCase							)
  						A__     :							Dict   				=output.images
  
  						A__     :							Union[str, Any]   				=image.cpu().permute(0	,     2	,     3	,     1							)[0]
  						A__     :							Optional[int]   				=mask_image.cpu().permute(0	,     2	,     3	,     1							)[0]
  
  						A__     :							List[Any]   				=Image.fromarray(np.uinta(__UpperCamelCase							)							).convert('''RGB'''							)
  						A__     :							str   				=Image.fromarray(np.uinta(__UpperCamelCase							)							).convert('''RGB'''							)
  
  						A__     :							Optional[Any]   				=pipe(**self.get_dummy_inputs()							)
  						A__     :							Optional[int]   				=output.images
  
  						assert out_a.shape == (1, 64, 64, 3)
  						assert np.abs(out_a.flatten() - out_a.flatten()							).max() < 5E-2
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Any:
  						'''simple docstring'''
  
  
  						super().test_inference_batch_single_identical(expected_max_diff=3E-3							)
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class 			a      (      unittest.TestCase   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						super().tearDown()
  						gc.collect()
  						torch.cuda.empty_cache()
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
  						'''simple docstring'''
  
  
  						A__     :							List[Any]   				=load_image(
  						    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
  						    '''/paint_by_example/dog_in_bucket.png'''							)
  						A__     :							str   				=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__     :							Tuple   				=PaintByExamplePipeline.from_pretrained('''Fantasy-Studio/Paint-by-Example'''							)
  						A__     :							Optional[Any]   				=pipe.to(__UpperCamelCase							)
  						pipe.set_progress_bar_config(disable=__UpperCamelCase							)
  
  						A__     :							Any   				=torch.manual_seed(3_21							)
  						A__     :							Optional[Any]   				=pipe(
  						    image=__UpperCamelCase	,     mask_image=__UpperCamelCase	,     example_image=__UpperCamelCase	,     generator=__UpperCamelCase	,     guidance_scale=5.0	,     num_inference_steps=50	,     output_type='''np'''	,     )
  
  						A__     :							Optional[Any]   				=output.images
  
  						A__     :							Optional[int]   				=image[0, -3:, -3:, -1]
  
  						assert image.shape == (1, 5_12, 5_12, 3)
  						A__     :							List[str]   				=np.array([0.4834, 0.4811, 0.4874, 0.5122, 0.5081, 0.5144, 0.5291, 0.5290, 0.5374]							)
  
  						assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2
  
  
  
  
style_context: 
  
  
  import argparse
  import collections
  from pathlib import Path
  
  import torch
  from torch.serialization import default_restore_location
  
  from transformers import BertConfig, DPRConfig, DPRContextEncoder, DPRQuestionEncoder, DPRReader
  
  
  __lowerCamelCase       :       Optional[Any]				   =			collections.namedtuple(
      "CheckpointState", ["model_dict", "optimizer_dict", "scheduler_dict", "offset", "epoch", "encoder_params"]
  )
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							CheckpointState:
  				print(f'Reading saved model from {model_file}'	)
  				A__     :							Optional[int]   				=torch.load(snake_case_,	map_location=lambda snake_case_,	snake_case_	: default_restore_location(snake_case_,	'''cpu'''	)	)
  				return CheckpointState(**snake_case_	)
  
  
  
  class 			a      :
  
  
  
  
  
  
  		def __init__(  self	,     __UpperCamelCase							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						A__     :							Dict   				=src_file
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
  						'''simple docstring'''
  
  
  						raise NotImplementedError
  
  
  
  
  
  
  		@staticmethod
  		def       lowerCAmelCase_  (  __UpperCamelCase	,     *__UpperCamelCase	,     **__UpperCamelCase							)->			"DPRState":
  						'''simple docstring'''
  
  
  						if comp_type.startswith('''c'''							):
  										return DPRContextEncoderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						if comp_type.startswith('''q'''							):
  										return DPRQuestionEncoderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						if comp_type.startswith('''r'''							):
  										return DPRReaderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						else:
  										raise ValueError('''Component type must be either \'ctx_encoder\', \'question_encoder\' or \'reader\'.'''							)
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				=DPRContextEncoder(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR biencoder from {self.src_file}'							)
  						A__     :							Optional[int]   				=load_states_from_checkpoint(self.src_file							)
  						A__				,  A__     :							List[str]   				=model.ctx_encoder, '''ctx_model.'''
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[int]   				={'''bert_model.embeddings.position_ids''': model.ctx_encoder.bert_model.embeddings.position_ids}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith(__UpperCamelCase							):
  														A__     :							int   				=key[len(__UpperCamelCase							) :]
  														if not key.startswith('''encode_proj.'''							):
  																		A__     :							Any   				='''bert_model.''' + key
  														A__     :							List[str]   				=value
  						encoder.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Dict:
  						'''simple docstring'''
  
  
  						A__     :							Union[str, Any]   				=DPRQuestionEncoder(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR biencoder from {self.src_file}'							)
  						A__     :							List[str]   				=load_states_from_checkpoint(self.src_file							)
  						A__				,  A__     :							Optional[int]   				=model.question_encoder, '''question_model.'''
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[Any]   				={'''bert_model.embeddings.position_ids''': model.question_encoder.bert_model.embeddings.position_ids}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith(__UpperCamelCase							):
  														A__     :							List[Any]   				=key[len(__UpperCamelCase							) :]
  														if not key.startswith('''encode_proj.'''							):
  																		A__     :							Tuple   				='''bert_model.''' + key
  														A__     :							str   				=value
  						encoder.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			int:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				=DPRReader(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR reader from {self.src_file}'							)
  						A__     :							Dict   				=load_states_from_checkpoint(self.src_file							)
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[Any]   				={
  						    '''encoder.bert_model.embeddings.position_ids''': model.span_predictor.encoder.bert_model.embeddings.position_ids
  						}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith('''encoder.'''							) and not key.startswith('''encoder.encode_proj'''							):
  														A__     :							List[Any]   				='''encoder.bert_model.''' + key[len('''encoder.'''							) :]
  										A__     :							Optional[int]   				=value
  						model.span_predictor.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_,	snake_case_	)			->							Optional[int]:
  				A__     :							Optional[int]   				=Path(snake_case_	)
  				dest_dir.mkdir(exist_ok=snake_case_	)
  
  				A__     :							Tuple   				=DPRState.from_type(snake_case_,	src_file=snake_case_	)
  				A__     :							str   				=dpr_state.load_dpr_model()
  				model.save_pretrained(snake_case_	)
  				model.from_pretrained(snake_case_	)  # sanity check
  
  
  if __name__ == "__main__":
  						__lowerCamelCase       :       Optional[Any]				   =			argparse.ArgumentParser()
  						# Required parameters
  						parser.add_argument(
  						    "--type", type=str, help="Type of the component to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
  						)
  						parser.add_argument(
  						    "--src",
  						    type=str,
  						    help=(
  						        "Path to the dpr checkpoint file. They can be downloaded from the official DPR repo"
  						        " https://github.com/facebookresearch/DPR. Note that in the official repo, both encoders are stored in the"
  						        " 'retriever' checkpoints."
  						    ),
  						)
  						parser.add_argument("--dest", type=str, default=None, help="Path to the output PyTorch model directory.")
  						__lowerCamelCase       :       Tuple				   =			parser.parse_args()
  
  						__lowerCamelCase       :       Optional[Any]				   =			Path(args.src)
  						__lowerCamelCase       :       Optional[int]				   =			F"converted-{src_file.name}" if args.dest is None else args.dest
  						__lowerCamelCase       :       Optional[Any]				   =			Path(dest_dir)
  						assert src_file.exists()
  						assert (
  						    args.type is not None
  						), "Please specify the component type of the DPR model to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
  						convert(args.type, src_file, dest_dir)
  
  
  
  