code: 
  
  
  
  import os
  from pathlib import Path
  from typing import Dict, List
  
  import fire
  import torch
  
  from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
  from transformers.utils.logging import get_logger
  
  
  __lowerCamelCase  				=					get_logger(__name__)
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case							)   -> Dict:
    if text.startswith(__snake_case							):
      return text[len(__snake_case							) :]
    return text  # or whatever
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case							)   -> Dict:
    return {remove_prefix(__snake_case						,				'''model.'''							): v for k, v in sd.items()}
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case							)   -> Optional[int]:
    _A           =    {}
    for k in state_dicts[0].keys():
      _A           =    [sd[k] for sd in state_dicts]
      _A           =    sum(__snake_case							) / len(__snake_case							)
      assert isinstance(__snake_case						,				torch.Tensor							)
      _A           =    new_t
    return new_sd
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case							)   -> None:
    _A           =    AutoModelForSeqaSeqLM.from_pretrained(__snake_case							)
    if os.path.isfile(__snake_case							):
      _A           =    [pl_ckpt_path]
    else:
      assert os.path.isdir(__snake_case							)
      _A           =    list(Path(__snake_case							).glob('''*.ckpt'''							)							)
      assert ckpt_files, F'''could not find any ckpt files inside the {pl_ckpt_path} directory'''
  
    if len(__snake_case							) > 1:
      logger.info(F'''averaging the weights of {ckpt_files}'''							)
  
    _A           =    [sanitize(torch.load(__snake_case						,				map_location='''cpu'''							)['''state_dict''']							) for x in ckpt_files]
    _A           =    average_state_dicts(__snake_case							)
  
    _A    ,   _A           =    hf_model.load_state_dict(__snake_case						,				strict=__snake_case							)
    assert not missing, F'''missing keys: {missing}'''
    hf_model.save_pretrained(__snake_case							)
    try:
      _A           =    AutoTokenizer.from_pretrained(__snake_case							)
      tok.save_pretrained(__snake_case							)
    except Exception:
      pass
      # dont copy tokenizer if cant
  
  
  if __name__ == "__main__":
      fire.Fire(convert_pl_to_hf)
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
      )