



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)




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
    )