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 		_snake_case      (			a__					,unittest.TestCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			PaintByExamplePipeline
   lowerCamelCase_          =			IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
   lowerCamelCase_          =			IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowerCamelCase_          =			frozenset([]				)  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     torch.manual_seed(0					)
     _A           =    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           =    PNDMScheduler(skip_prk_steps=__A					)
     torch.manual_seed(0					)
     _A           =    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           =    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           =    PaintByExampleImageEncoder(__A	,    proj_size=3_2					)
     _A           =    CLIPImageProcessor(crop_size=3_2	,    size=3_2					)
  
     _A           =    {
         "unet": unet,
         "scheduler": scheduler,
         "vae": vae,
         "image_encoder": image_encoder,
         "safety_checker": None,
         "feature_extractor": feature_extractor,
     }
     return components
   def lowercase_		(						self	,    a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    np.array(image.convert('''RGB'''					)					)
     _A           =    image[None].transpose(0	,    3	,    1	,    2					)
     _A           =    torch.from_numpy(__A					).to(dtype=torch.floataa					) / 127.5 - 1.0
     return image
   def lowercase_		(						self	,    a="cpu"	,    a=0					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    floats_tensor((1, 3, 3_2, 3_2)	,    rng=random.Random(__A					)					).to(__A					)
     _A           =    image.cpu().permute(0	,    2	,    3	,    1					)[0]
     _A           =    Image.fromarray(np.uinta(__A					)					).convert('''RGB'''					).resize((6_4, 6_4)					)
     _A           =    Image.fromarray(np.uinta(image + 4					)					).convert('''RGB'''					).resize((6_4, 6_4)					)
     _A           =    Image.fromarray(np.uinta(__A					)					).convert('''RGB'''					).resize((3_2, 3_2)					)
  
     if str(__A					).startswith('''mps'''					):
       _A           =    torch.manual_seed(__A					)
     else:
       _A           =    torch.Generator(device=__A					).manual_seed(__A					)
     _A           =    {
         "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 lowercase_		(						self					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.get_dummy_components()
  
     # make sure here that pndm scheduler skips prk
     _A           =    PaintByExamplePipeline(**__A					)
     _A           =    pipe.to('''cpu'''					)
     pipe.set_progress_bar_config(disable=__A					)
  
     _A           =    self.get_dummy_inputs()
     _A           =    pipe(**__A					)
     _A           =    output.images
  
     _A           =    image[0, -3:, -3:, -1]
  
     assert image.shape == (1, 6_4, 6_4, 3)
     _A           =    np.array([0.4_686, 0.5_687, 0.4_007, 0.5_218, 0.5_741, 0.4_482, 0.4_940, 0.4_629, 0.4_503]					)
  
     assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    "cpu"
     _A           =    self.get_dummy_inputs()
     inputs.pop('''mask_image'''					)
     _A           =    self.convert_to_pt(inputs.pop('''image'''					)					)
     _A           =    image.clamp(0	,    1					) / 2
  
     # make sure here that pndm scheduler skips prk
     _A           =    PaintByExamplePipeline(**self.get_dummy_components()					)
     _A           =    pipe.to(__A					)
     pipe.set_progress_bar_config(disable=__A					)
  
     _A           =    pipe(image=__A	,    mask_image=mask_image[:, 0]	,    **__A					)
     _A           =    output.images
  
     _A           =    image.cpu().permute(0	,    2	,    3	,    1					)[0]
     _A           =    mask_image.cpu().permute(0	,    2	,    3	,    1					)[0]
  
     _A           =    Image.fromarray(np.uinta(__A					)					).convert('''RGB'''					)
     _A           =    Image.fromarray(np.uinta(__A					)					).convert('''RGB'''					)
  
     _A           =    pipe(**self.get_dummy_inputs()					)
     _A           =    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 lowercase_		(						self					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     super().test_inference_batch_single_identical(expected_max_diff=3e-3					)
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class 		_snake_case      (			unittest.TestCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()
  
  
  
   def lowercase_		(						self					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/paint_by_example/dog_in_bucket.png'''					)
     _A           =    load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/paint_by_example/mask.png'''					)
     _A           =    load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/paint_by_example/panda.jpg'''					)
  
     _A           =    PaintByExamplePipeline.from_pretrained('''Fantasy-Studio/Paint-by-Example'''					)
     _A           =    pipe.to(__A					)
     pipe.set_progress_bar_config(disable=__A					)
  
     _A           =    torch.manual_seed(3_2_1					)
     _A           =    pipe(
         image=__A	,    mask_image=__A	,    example_image=__A	,    generator=__A	,    guidance_scale=5.0	,    num_inference_steps=5_0	,    output_type='''np'''	,    )
  
     _A           =    output.images
  
     _A           =    image[0, -3:, -3:, -1]
  
     assert image.shape == (1, 5_1_2, 5_1_2, 3)
     _A           =    np.array([0.4_834, 0.4_811, 0.4_874, 0.5_122, 0.5_081, 0.5_144, 0.5_291, 0.5_290, 0.5_374]					)
  
     assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
style_context: 
  
  
  
  import argparse
  
  import torch
  
  from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case						,				__snake_case							)   -> Tuple:
    # Initialise PyTorch model
    _A           =    ElectraConfig.from_json_file(__snake_case							)
    print(F'''Building PyTorch model from configuration: {config}'''							)
  
    if discriminator_or_generator == "discriminator":
      _A           =    ElectraForPreTraining(__snake_case							)
    elif discriminator_or_generator == "generator":
      _A           =    ElectraForMaskedLM(__snake_case							)
    else:
      raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''							)
  
    # Load weights from tf checkpoint
    load_tf_weights_in_electra(
        __snake_case						,				__snake_case						,				__snake_case						,				discriminator_or_generator=__snake_case							)
  
    # Save pytorch-model
    print(F'''Save PyTorch model to {pytorch_dump_path}'''							)
    torch.save(model.state_dict()						,				__snake_case							)
  
  
  if __name__ == "__main__":
      __lowerCamelCase  				=					argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
      )
      parser.add_argument(
          """--config_file""",
          default=None,
          type=str,
          required=True,
          help="""The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.""",
      )
      parser.add_argument(
          """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
      )
      parser.add_argument(
          """--discriminator_or_generator""",
          default=None,
          type=str,
          required=True,
          help=(
              """Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or """
              """'generator'."""
          ),
      )
      __lowerCamelCase  				=					parser.parse_args()
      convert_tf_checkpoint_to_pytorch(
          args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
      )