code: 
  
  
  
  import tempfile
  import unittest
  
  import torch
  
  from diffusers import UNetaDConditionModel
  from diffusers.training_utils import EMAModel
  from diffusers.utils.testing_utils import enable_full_determinism, skip_mps, torch_device
  
  
  enable_full_determinism()
  
  
  
  class 		_snake_case      (			unittest.TestCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			'''hf-internal-testing/tiny-stable-diffusion-pipe'''
   lowerCamelCase_          =			1
   lowerCamelCase_          =			7_7
   lowerCamelCase_          =			3_2
   lowerCamelCase_          =			4
   lowerCamelCase_          =			lowerCamelCase_          =			6_4
   lowerCamelCase_          =			torch.manual_seed(0				)
   def lowercase_		(						self	,    a=0.9_999					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    UNetaDConditionModel.from_pretrained(self.model_id	,    subfolder='''unet'''					)
     _A           =    unet.to(a					)
     _A           =    EMAModel(unet.parameters()	,    decay=a	,    model_cls=a	,    model_config=unet.config					)
     return unet, ema_unet
   def lowercase_		(						self					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    torch.randn(
         self.batch_size	,    self.num_in_channels	,    self.latent_height	,    self.latent_width	,    generator=self.generator					).to(a					)
     _A           =    torch.randint(0	,    1_0_0_0	,    size=(self.batch_size,)	,    generator=self.generator					).to(a					)
     _A           =    torch.randn(
         self.batch_size	,    self.prompt_length	,    self.text_encoder_hidden_dim	,    generator=self.generator					).to(a					)
     return noisy_latents, timesteps, encoder_hidden_states
   def lowercase_		(						self	,    a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    {}
     for k, param in unet.state_dict().items():
       _A           =    torch.randn_like(a					) + (param * torch.randn_like(a					))
       updated_state_dict.update({k: updated_param}					)
     unet.load_state_dict(a					)
     return unet
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models()
     # Take the first (hypothetical) EMA step.
     ema_unet.step(unet.parameters()					)
     assert ema_unet.optimization_step == 1
  
     # Take two more.
     for _ in range(2					):
       ema_unet.step(unet.parameters()					)
     assert ema_unet.optimization_step == 3
   def lowercase_		(						self					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models()
     # Since the `unet` is not being updated (i.e., backprop'd)
     # there won't be any difference between the `params` of `unet`
     # and `ema_unet` even if we call `ema_unet.step(unet.parameters())`.
     ema_unet.step(unet.parameters()					)
     _A           =    list(unet.parameters()					)
     for s_param, param in zip(ema_unet.shadow_params	,    a					):
       assert torch.allclose(a	,    a					)
  
     # The above holds true even if we call `ema.step()` multiple times since
     # `unet` params are still not being updated.
     for _ in range(4					):
       ema_unet.step(unet.parameters()					)
     for s_param, param in zip(ema_unet.shadow_params	,    a					):
       assert torch.allclose(a	,    a					)
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models()
     # Here we simulate the parameter updates for `unet`. Since there might
     # be some parameters which are initialized to zero we take extra care to
     # initialize their values to something non-zero before the multiplication.
     _A           =    self.simulate_backprop(a					)
  
     # Take the EMA step.
     ema_unet.step(unet_pseudo_updated_step_one.parameters()					)
  
     # Now the EMA'd parameters won't be equal to the original model parameters.
     _A           =    list(unet_pseudo_updated_step_one.parameters()					)
     for s_param, param in zip(ema_unet.shadow_params	,    a					):
       assert ~torch.allclose(a	,    a					)
  
     # Ensure this is the case when we take multiple EMA steps.
     for _ in range(4					):
       ema_unet.step(unet.parameters()					)
     for s_param, param in zip(ema_unet.shadow_params	,    a					):
       assert ~torch.allclose(a	,    a					)
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models()
  
     # First backprop + EMA
     _A           =    self.simulate_backprop(a					)
     ema_unet.step(unet_step_one.parameters()					)
     _A           =    ema_unet.shadow_params
  
     # Second backprop + EMA
     _A           =    self.simulate_backprop(a					)
     ema_unet.step(unet_step_two.parameters()					)
     _A           =    ema_unet.shadow_params
  
     for step_one, step_two in zip(a	,    a					):
       assert ~torch.allclose(a	,    a					)
   def lowercase_		(						self					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models(decay=0.0					)
     _A           =    self.simulate_backprop(a					)
     ema_unet.step(unet_step_one.parameters()					)
     _A           =    ema_unet.shadow_params
  
     _A           =    self.simulate_backprop(a					)
     ema_unet.step(unet_step_two.parameters()					)
     _A           =    ema_unet.shadow_params
  
     for step_one, step_two in zip(a	,    a					):
       assert torch.allclose(a	,    a					)
  
  
  
   @skip_mps
   def lowercase_		(						self					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A    ,   _A           =    self.get_models()
     _A    ,   _A    ,   _A           =    self.get_dummy_inputs()
  
     with tempfile.TemporaryDirectory() as tmpdir:
       ema_unet.save_pretrained(a					)
       _A           =    UNetaDConditionModel.from_pretrained(a	,    model_cls=a					)
       _A           =    loaded_unet.to(unet.device					)
  
     # Since no EMA step has been performed the outputs should match.
     _A           =    unet(a	,    a	,    a					).sample
     _A           =    loaded_unet(a	,    a	,    a					).sample
  
     assert torch.allclose(a	,    a	,    atol=1e-4					)
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
      )